* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * Copyright(c) 2014 6WIND S.A.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
return prefix;
}
-/* extra function prototypes for internal eal function to test in whitelist
- * ICC 12 doesn't approve of this practice, so temporarily disable warnings for it */
-#ifdef __INTEL_COMPILER
-#pragma warning disable 1419
-#endif
-extern int eal_dev_whitelist_exists(void);
-extern int eal_dev_whitelist_add_entry(const char *);
-extern int eal_dev_whitelist_parse(void);
-extern int eal_dev_is_whitelisted(const char *, const char **);
-extern void eal_dev_whitelist_clear(void);
-#ifdef __INTEL_COMPILER
-#pragma warning enable 1419
-#endif
-
/*
* Test that the app doesn't run with invalid whitelist option.
* Final tests ensures it does run with valid options as sanity check (one
use_device, "error0:0:0.1", "", ""},
{prgname, prefix, mp_flag, "-n", "1", "-c", "1",
use_device, "0:0:0.1.2", "", ""},
- {prgname, prefix, mp_flag, "-n", "1", "-c", "1",
- use_device, "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x",
- use_device, "y,z,1,2,3,4,5,6,7,8,9,0"},
};
/* Test with valid whitelist option */
const char *wlval1[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1",
use_device, "00FF:09:0B.3"};
const char *wlval2[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1",
- use_device, "09:0B.3,0a:0b.1"};
+ use_device, "09:0B.3", use_device, "0a:0b.1"};
const char *wlval3[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1",
- use_device, "09:0B.3;type=test,08:00.1;type=normal"};
+ use_device, "09:0B.3;type=test",
+ use_device, "08:00.1;type=normal"};
for (i = 0; i < sizeof(wlinval) / sizeof(wlinval[0]); i++) {
if (launch_proc(wlinval[i]) == 0) {
return -1;
}
- /* extra-sanity checks of whitelists - to be run only if no whitelist */
- if (eal_dev_whitelist_exists())
- return 0;
-
- /* check that whitelist_parse returns error without whitelist */
- if (eal_dev_whitelist_parse() != -1) {
- printf("ERROR: calling whitelist parse without a whitelist doesn't "
- "return an error\n");
- return -1;
- }
- if (eal_dev_is_whitelisted("adevice", NULL)) {
- printf("Whitelist lookup does not return false if no whitelist\n");
- return -1;
- }
- eal_dev_whitelist_add_entry("0000:00:00.0");
- eal_dev_whitelist_parse();
- if (eal_dev_is_whitelisted("adevice", NULL)) {
- printf("Whitelist lookup does not return false for unlisted dev\n");
- return -1;
- }
- if (!eal_dev_is_whitelisted("0000:00:00.0", NULL)) {
- printf("Whitelist lookup does not return true for whitelisted dev\n");
- return -1;
- }
- eal_dev_whitelist_clear();
-
return 0;
}
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * Copyright(c) 2014 6WIND S.A.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include <rte_interrupts.h>
#include <rte_pci.h>
+#include <rte_devargs.h>
#include "test.h"
-#define TEST_BLACKLIST_NUM 0x100
-
/*
* PCI test
* ========
int test_pci_run = 0; /* value checked by the multiprocess test */
static unsigned pci_dev_count;
static unsigned driver_registered = 0;
-static struct rte_pci_addr blacklist[TEST_BLACKLIST_NUM];
static int my_driver_init(struct rte_pci_driver *dr,
struct rte_pci_device *dev);
return 0;
}
-static void
-blacklist_clear(void)
-{
- rte_eal_pci_set_blacklist(NULL, 0);
-}
-
-
-
static void
blacklist_all_devices(void)
{
struct rte_pci_device *dev = NULL;
- unsigned idx = 0;
-
- memset(blacklist, 0, sizeof (blacklist));
+ unsigned i = 0;
+ char pci_addr_str[16];
TAILQ_FOREACH(dev, &pci_device_list, next) {
- if (idx >= sizeof (blacklist) / sizeof (blacklist[0])) {
- printf("Error: too many devices to blacklist");
+ snprintf(pci_addr_str, sizeof(pci_addr_str), PCI_PRI_FMT,
+ dev->addr.domain, dev->addr.bus, dev->addr.devid,
+ dev->addr.function);
+ if (rte_eal_devargs_add(RTE_DEVTYPE_BLACKLISTED_PCI,
+ pci_addr_str) < 0) {
+ printf("Error: cannot blacklist <%s>", pci_addr_str);
break;
}
- blacklist[idx] = dev->addr;
- ++idx;
+ i++;
}
+ printf("%u devices blacklisted\n", i);
+}
+
+/* clear devargs list that was modified by the test */
+static void free_devargs_list(void)
+{
+ struct rte_devargs *devargs;
- rte_eal_pci_set_blacklist(blacklist, idx);
- printf("%u devices blacklisted\n", idx);
+ while (!TAILQ_EMPTY(&devargs_list)) {
+ devargs = TAILQ_FIRST(&devargs_list);
+ TAILQ_REMOVE(&devargs_list, devargs, next);
+ free(devargs);
+ }
}
int
test_pci(void)
{
+ struct rte_devargs_list save_devargs_list;
printf("Dump all devices\n");
rte_eal_pci_dump();
return -1;
}
+ /* save the real devargs_list */
+ save_devargs_list = devargs_list;
+ TAILQ_INIT(&devargs_list);
+
blacklist_all_devices();
pci_dev_count = 0;
printf("Scan bus with all devices blacklisted\n");
rte_eal_pci_probe();
- blacklist_clear();
+ free_devargs_list();
+ devargs_list = save_devargs_list;
if (pci_dev_count != 0) {
printf("not all devices are blacklisted\n");
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * Copyright(c) 2014 6WIND S.A.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <string.h>
#include <inttypes.h>
#include <rte_string_fns.h>
#ifdef RTE_LIBRTE_PMD_RING
#ifdef RTE_LIBRTE_PMD_XENVIRT
#include <rte_eth_xenvirt.h>
#endif
+#include <rte_debug.h>
+#include <rte_devargs.h>
#include "eal_private.h"
struct device_init {
int
rte_eal_non_pci_ethdev_init(void)
{
- uint8_t i, j;
- for (i = 0; i < NUM_DEV_TYPES; i++) {
- for (j = 0; j < RTE_MAX_ETHPORTS; j++) {
- const char *params;
- char buf[16];
- rte_snprintf(buf, sizeof(buf), "%s%"PRIu8,
- dev_types[i].dev_prefix, j);
- if (eal_dev_is_whitelisted(buf, ¶ms))
- dev_types[i].init_fn(buf, params);
+ struct rte_devargs *devargs;
+ uint8_t i;
+
+ /* call the init function for each virtual device */
+ TAILQ_FOREACH(devargs, &devargs_list, next) {
+
+ if (devargs->type != RTE_DEVTYPE_VIRTUAL)
+ continue;
+
+ for (i = 0; i < NUM_DEV_TYPES; i++) {
+ /* search a driver prefix in virtual device name */
+ if (!strncmp(dev_types[i].dev_prefix,
+ devargs->virtual.drv_name,
+ sizeof(dev_types[i].dev_prefix) - 1)) {
+ dev_types[i].init_fn(devargs->virtual.drv_name,
+ devargs->args);
+ break;
+ }
+ }
+
+ if (i == NUM_DEV_TYPES) {
+ rte_panic("no driver found for %s\n",
+ devargs->virtual.drv_name);
}
}
return 0;
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <string.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdlib.h>
#include <rte_eal.h>
#include <rte_string_fns.h>
#include <rte_common.h>
+#include <rte_devargs.h>
#include "eal_private.h"
struct pci_driver_list pci_driver_list;
struct pci_device_list pci_device_list;
-static struct rte_pci_addr *dev_blacklist = NULL;
-static unsigned dev_blacklist_size = 0;
-
static int is_blacklisted(struct rte_pci_device *dev)
{
- struct rte_pci_addr *loc = &dev->addr;
- unsigned i;
-
- for (i = 0; i < dev_blacklist_size; i++) {
- if ((loc->domain == dev_blacklist[i].domain) &&
- (loc->bus == dev_blacklist[i].bus) &&
- (loc->devid == dev_blacklist[i].devid) &&
- (loc->function == dev_blacklist[i].function)) {
+ struct rte_devargs *devargs;
+
+ TAILQ_FOREACH(devargs, &devargs_list, next) {
+ if (devargs->type != RTE_DEVTYPE_BLACKLISTED_PCI)
+ continue;
+ if (!memcmp(&dev->addr, &devargs->pci.addr, sizeof(dev->addr)))
return 1;
- }
}
-
return 0; /* not in blacklist */
}
static int
pcidev_is_whitelisted(struct rte_pci_device *dev)
{
- char buf[16];
- if (dev->addr.domain == 0) {
- rte_snprintf(buf, sizeof(buf), PCI_SHORT_PRI_FMT, dev->addr.bus,
- dev->addr.devid, dev->addr.function);
- if (eal_dev_is_whitelisted(buf, NULL))
+ struct rte_devargs *devargs;
+
+ TAILQ_FOREACH(devargs, &devargs_list, next) {
+ if (devargs->type != RTE_DEVTYPE_WHITELISTED_PCI)
+ continue;
+ if (!memcmp(&dev->addr, &devargs->pci.addr, sizeof(dev->addr)))
return 1;
}
- rte_snprintf(buf, sizeof(buf), PCI_PRI_FMT, dev->addr.domain,dev->addr.bus,
- dev->addr.devid, dev->addr.function);
- return eal_dev_is_whitelisted(buf, NULL);
+ return 0;
}
/*
rte_eal_pci_probe(void)
{
struct rte_pci_device *dev = NULL;
+ int probe_all = 0;
- TAILQ_FOREACH(dev, &pci_device_list, next)
- if (!eal_dev_whitelist_exists())
+ if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) == 0)
+ probe_all = 1;
+
+ TAILQ_FOREACH(dev, &pci_device_list, next) {
+ if (probe_all)
pci_probe_all_drivers(dev);
- else if (pcidev_is_whitelisted(dev) && pci_probe_all_drivers(dev) < 0 )
- rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
- " cannot be used\n", dev->addr.domain,dev->addr.bus,
- dev->addr.devid, dev->addr.function);
+ else if (pcidev_is_whitelisted(dev) && pci_probe_all_drivers(dev) < 0)
+ rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
+ " cannot be used\n", dev->addr.domain, dev->addr.bus,
+ dev->addr.devid, dev->addr.function);
+ }
return 0;
}
{
TAILQ_REMOVE(&pci_driver_list, driver, next);
}
-
-void
-rte_eal_pci_set_blacklist(struct rte_pci_addr *blacklist, unsigned size)
-{
- dev_blacklist = blacklist;
- dev_blacklist_size = size;
-}
+++ /dev/null
-/*-
- * 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.
- */
-
-
-/**
- * This file provides functions for managing a whitelist of devices. An EAL
- * command-line parameter should be used for specifying what devices to
- * whitelist, and the functions here should be called in handling that
- * parameter. Then when scanning the PCI bus, the is_whitelisted() function
- * can be used to query the previously set up whitelist.
- */
-#include <string.h>
-#include <rte_string_fns.h>
-#include <rte_log.h>
-#include <rte_debug.h>
-#include <rte_pci.h>
-#include <ctype.h>
-#ifdef RTE_LIBRTE_PMD_RING
-#include <rte_eth_ring.h>
-#endif
-#ifdef RTE_LIBRTE_PMD_PCAP
-#include <rte_eth_pcap.h>
-#endif
-#ifdef RTE_LIBRTE_PMD_XENVIRT
-#include <rte_eth_xenvirt.h>
-#endif
-#include "eal_private.h"
-
-static char dev_list_str[4096];
-static size_t dev_list_str_len = 0;
-
-/*
- * structure for storing a whitelist entry. Unlike for blacklists, we may
- * in future use this for dummy NICs not backed by a physical device, e.g.
- * backed by a file-system object instead, so we store the device path/addr
- * as a string, rather than as a PCI Bus-Device-Function.
- */
-static struct whitelist_entry {
- const char *device_str;
- const char *device_params;
-} whitelist[RTE_MAX_ETHPORTS] = { {NULL, NULL} };
-
-static unsigned num_wl_entries = 0;
-
-/* store a whitelist parameter for later parsing */
-int
-eal_dev_whitelist_add_entry(const char *entry)
-{
- dev_list_str_len += rte_snprintf(&dev_list_str[dev_list_str_len],
- sizeof(dev_list_str)-dev_list_str_len, "%s,", entry);
- /* check for strings that won't fit (snprintf doesn't go beyond buffer) */
- if (dev_list_str_len >= sizeof(dev_list_str)) {
- dev_list_str_len = sizeof(dev_list_str) - 1;
- return -1;
- }
-
- return 0;
-}
-
-/* check if a whitelist has been set up */
-int
-eal_dev_whitelist_exists(void)
-{
- return !!dev_list_str_len;
-}
-
-/* sanity checks a whitelist entry to ensure device is correct */
-static int
-is_valid_wl_entry(const char *device_str, size_t dev_buf_len)
-{
-#define NUM_PREFIXES (sizeof(non_pci_prefixes)/sizeof(non_pci_prefixes[0]))
- static const char *non_pci_prefixes[] = {
-#ifdef RTE_LIBRTE_PMD_RING
- RTE_ETH_RING_PARAM_NAME,
-#endif
-#ifdef RTE_LIBRTE_PMD_PCAP
- RTE_ETH_PCAP_PARAM_NAME,
-#endif
-#ifdef RTE_LIBRTE_PMD_XENVIRT
- RTE_ETH_XENVIRT_PARAM_NAME,
-#endif
- "-nodev-" /* dummy value to prevent compiler warnings */
- };
- static uint8_t prefix_counts[NUM_PREFIXES] = {0};
- char buf[16];
- unsigned i;
- struct rte_pci_addr pci_addr = { .domain = 0 };
-
- if (eal_parse_pci_BDF(device_str, &pci_addr) == 0) {
- size_t n = rte_snprintf(buf, sizeof(buf), PCI_SHORT_PRI_FMT,
- pci_addr.bus, pci_addr.devid, pci_addr.function);
- return (n == dev_buf_len) && (!strncmp(buf, device_str, dev_buf_len));
- }
- if (eal_parse_pci_DomBDF(device_str, &pci_addr) == 0) {
- size_t n = rte_snprintf(buf, sizeof(buf), PCI_PRI_FMT, pci_addr.domain,
- pci_addr.bus, pci_addr.devid, pci_addr.function);
- return (n == dev_buf_len) && (!strncmp(buf, device_str, dev_buf_len));
- }
- for (i = 0; i < NUM_PREFIXES; i++) {
- size_t n = rte_snprintf(buf, sizeof(buf), "%s%u",
- non_pci_prefixes[i], prefix_counts[i]);
- if ((n == dev_buf_len) && (!strncmp(buf, device_str, dev_buf_len))) {
- prefix_counts[i]++;
- return 1;
- }
- }
- return 0;
-}
-
-/*
- * parse a whitelist string into a set of valid devices. To be called once
- * all parameters have been added to the whitelist string.
- */
-int
-eal_dev_whitelist_parse(void)
-{
- char *devs[RTE_MAX_ETHPORTS + 1] = { NULL };
- int i, num_devs;
- unsigned dev_name_len, j;
-
- if (!eal_dev_whitelist_exists())
- return -1;
-
- /* strip off any extra commas */
- if (dev_list_str[dev_list_str_len - 1] == ',')
- dev_list_str[--dev_list_str_len] = '\0';
-
- /* split on commas into separate device entries */
- num_devs = rte_strsplit(dev_list_str, sizeof(dev_list_str), devs,
- RTE_MAX_ETHPORTS+1, ',');
- if (num_devs > RTE_MAX_ETHPORTS) {
- RTE_LOG(ERR, EAL, "Error, too many devices specified. "
- "[RTE_MAX_ETHPORTS = %u]\n", (unsigned)RTE_MAX_ETHPORTS);
- return -1;
- }
-
- size_t buf_len_rem = sizeof(dev_list_str); /* for tracking buffer length */
- for (i = 0; i < num_devs; i++) {
- char *dev_n_params[2]; /* possibly split device name from params*/
-
- size_t curr_len = strnlen(devs[i], buf_len_rem);
- buf_len_rem-= (curr_len + 1);
-
- int split_res = rte_strsplit(devs[i], curr_len, dev_n_params, 2, ';');
-
- /* device names go lower case, i.e. '00:0A.0' wouldn't work
- * while '00:0a.0' would. */
- dev_name_len = strnlen(dev_n_params[0], curr_len);
- for (j = 0; j < dev_name_len; j++)
- dev_n_params[0][j] = (char)tolower((int)dev_n_params[0][j]);
-
- switch (split_res) {
- case 2:
- whitelist[i].device_params = dev_n_params[1]; /* fallthrough */
- case 1:
- whitelist[i].device_str = dev_n_params[0];
- break;
- default: /* should never ever occur */
- rte_panic("Fatal error parsing whitelist [--use-device] options\n");
- }
-
- if (!is_valid_wl_entry(whitelist[i].device_str,
- strnlen(whitelist[i].device_str, curr_len))) {
- RTE_LOG(ERR, EAL, "Error parsing device identifier: '%s'\n",
- whitelist[i].device_str);
- return -1;
- }
- }
- num_wl_entries = num_devs;
- return 0;
-}
-
-/* check if a device is on the whitelist */
-int
-eal_dev_is_whitelisted(const char *device_str, const char **params)
-{
- unsigned i;
- if (!eal_dev_whitelist_exists())
- return 0; /* return false if no whitelist set up */
-
- for (i = 0; i < num_wl_entries; i++)
- if (strncmp(device_str, whitelist[i].device_str, 32) == 0) {
- if (params != NULL)
- *params = whitelist[i].device_params;
- return 1;
- }
-
- return 0;
-}
-
-/* clear the whole whitelist */
-void
-eal_dev_whitelist_clear(void)
-{
- dev_list_str[0] = '\0';
- dev_list_str_len = num_wl_entries = 0;
-}
*/
int rte_eal_alarm_init(void);
-/**
- * When parsing command-line args add a new entry to the whitelist string
- * to be parsed, i.e. this is used to join multiple --use-device flags together
- *
- * This function is private to EAL
- */
-int eal_dev_whitelist_add_entry(const char *entry);
-
-/**
- * Returns true if whitelist parameters are available for parsing,
- * false otherwise.
- *
- * This function is private to EAL
- */
-int eal_dev_whitelist_exists(void);
-
-/**
- * Parse the combined whitelist options into a single white-list for later use.
- *
- * This function is private to EAL
- */
-int eal_dev_whitelist_parse(void);
-
-/**
- * Check if a particular device is whitelisted or not. Returns true if the
- * device is in the whitelist.
- *
- * This function is private to EAL
- */
-int eal_dev_is_whitelisted(const char *device_str, const char **params);
-
-/**
- * This function clears the whitelist settings.
- *
- * This function is private to the EAL.
- */
-void eal_dev_whitelist_clear(void);
-
/**
* This function initialises any non-PCI i.e. dummy ethernet devices
*
*/
void rte_eal_pci_unregister(struct rte_pci_driver *driver);
-/**
- * Register a list of PCI locations that will be blacklisted (not used by DPDK).
- *
- * @param blacklist
- * List of PCI device addresses that will not be used by DPDK.
- * @param size
- * Number of items in the list.
- */
-void rte_eal_pci_set_blacklist(struct rte_pci_addr *blacklist, unsigned size);
-
#ifdef __cplusplus
}
#endif
SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_errno.c
SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_cpuflags.c
SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_hexdump.c
-SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_whitelist.c
SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_devargs.c
SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_nonpci_devs.c
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- * Copyright(c) 2012-2013 6WIND S.A.
+ * Copyright(c) 2012-2014 6WIND S.A.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include <rte_cpuflags.h>
#include <rte_interrupts.h>
#include <rte_pci.h>
+#include <rte_devargs.h>
#include <rte_common.h>
#include <rte_version.h>
#include <rte_atomic.h>
.mem_config = &early_mem_config,
};
-static struct rte_pci_addr eal_dev_blacklist[RTE_EAL_BLACKLIST_SIZE];
-
/* internal configuration (per-core) */
struct lcore_config lcore_config[RTE_MAX_LCORE];
" --"OPT_HUGE_DIR" : directory where hugetlbfs is mounted\n"
" --"OPT_PROC_TYPE" : type of this process\n"
" --"OPT_FILE_PREFIX": prefix for hugepage filenames\n"
- " --"OPT_USE_DEVICE": use the specified ethernet device(s) only. "
- "Use comma-separate <[domain:]bus:devid.func> values.\n"
- " [NOTE: Cannot be used with -b option]\n"
+ " --"OPT_USE_DEVICE": use the specified ethernet device(s) only.\n"
+ " The argument format is <[domain:]bus:devid.func> to add\n"
+ " a PCI device to the white list or <driver><id>[;key=val;...]\n"
+ " to add a virtual device.\n"
+ " [NOTE: PCI whitelist cannot be used with -b option]\n"
" --"OPT_VMWARE_TSC_MAP": use VMware TSC map instead of "
"native RDTSC\n"
" --"OPT_BASE_VIRTADDR": specify base virtual address\n"
return RTE_PROC_INVALID;
}
-static ssize_t
-eal_parse_blacklist_opt(const char *optarg, size_t idx)
+static int
+eal_parse_use_device(const char *optarg)
{
- if (idx >= sizeof (eal_dev_blacklist) / sizeof (eal_dev_blacklist[0])) {
- RTE_LOG(ERR, EAL, "%s - too many devices to blacklist...\n", optarg);
- return (-EINVAL);
- } else if (eal_parse_pci_DomBDF(optarg, eal_dev_blacklist + idx) < 0 &&
- eal_parse_pci_BDF(optarg, eal_dev_blacklist + idx) < 0) {
- RTE_LOG(ERR, EAL, "%s - invalid device to blacklist...\n", optarg);
- return (-EINVAL);
+ struct rte_pci_addr addr;
+ char *dup, *sep;
+
+ dup = strdup(optarg);
+ if (dup == NULL)
+ return -1;
+
+ /* remove arguments in 'dup' string */
+ sep = strchr(dup, ';');
+ if (sep != NULL)
+ *sep = '\0';
+
+ /* if argument is a PCI address, it's a whitelisted device */
+ if (eal_parse_pci_DomBDF(dup, &addr) == 0 ||
+ eal_parse_pci_BDF(dup, &addr) == 0) {
+ rte_eal_devargs_add(RTE_DEVTYPE_WHITELISTED_PCI, optarg);
+ } else {
+ rte_eal_devargs_add(RTE_DEVTYPE_VIRTUAL, optarg);
}
- idx += 1;
- return (idx);
+ free(dup);
+ return 0;
}
/* Parse the argument given in the command line of the application */
char **argvopt;
int option_index;
int coremask_ok = 0;
- ssize_t blacklist_index = 0;
char *prgname = argv[0];
static struct option lgopts[] = {
{OPT_NO_HUGE, 0, 0, 0},
switch (opt) {
/* blacklist */
case 'b':
- if ((blacklist_index = eal_parse_blacklist_opt(optarg,
- blacklist_index)) < 0) {
+ if (rte_eal_devargs_add(RTE_DEVTYPE_BLACKLISTED_PCI,
+ optarg) < 0) {
eal_usage(prgname);
return (-1);
}
}
}
else if (!strcmp(lgopts[option_index].name, OPT_USE_DEVICE)) {
- eal_dev_whitelist_add_entry(optarg);
+ if (eal_parse_use_device(optarg) < 0) {
+ RTE_LOG(ERR, EAL, "invalid parameters for --"
+ OPT_USE_DEVICE "\n");
+ eal_usage(prgname);
+ return -1;
+ }
}
else if (!strcmp(lgopts[option_index].name, OPT_SYSLOG)) {
if (eal_parse_syslog(optarg) < 0) {
eal_usage(prgname);
return -1;
}
- /* if no blacklist, parse a whitelist */
- if (blacklist_index > 0) {
- if (eal_dev_whitelist_exists()) {
- RTE_LOG(ERR, EAL, "Error: blacklist [-b] and whitelist "
- "[--use-device] options cannot be used at the same time\n");
- eal_usage(prgname);
- return -1;
- }
- rte_eal_pci_set_blacklist(eal_dev_blacklist, blacklist_index);
- } else {
- if (eal_dev_whitelist_exists() && eal_dev_whitelist_parse() < 0) {
- RTE_LOG(ERR,EAL, "Error parsing whitelist[--use-device] options\n");
- return -1;
- }
+
+ if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) != 0 &&
+ rte_eal_devargs_type_count(RTE_DEVTYPE_BLACKLISTED_PCI) != 0) {
+ RTE_LOG(ERR, EAL, "Error: blacklist [-b] and whitelist "
+ "[--use-device] options cannot be used at the same time\n");
+ eal_usage(prgname);
+ return -1;
}
if (optind >= 0)
{
RTE_LOG(INFO, PMD, "Initializing pmd_ring for %s\n", name);
- if (params == NULL)
+ if (params == NULL || params[0] == '\0')
eth_dev_ring_create(name, rte_socket_id(), DEV_CREATE);
else {
RTE_LOG(INFO, PMD, "Ignoring unsupported parameters when creating"
git.droids-corp.org / dpdk.git / commitdiff