app/test/test_pci.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   Copyright(c) 2014 6WIND S.A.
   6  *   All rights reserved.
   7  *
   8  *   Redistribution and use in source and binary forms, with or without
   9  *   modification, are permitted provided that the following conditions
  10  *   are met:
  11  *
  12  *     * Redistributions of source code must retain the above copyright
  13  *       notice, this list of conditions and the following disclaimer.
  14  *     * Redistributions in binary form must reproduce the above copyright
  15  *       notice, this list of conditions and the following disclaimer in
  16  *       the documentation and/or other materials provided with the
  17  *       distribution.
  18  *     * Neither the name of Intel Corporation nor the names of its
  19  *       contributors may be used to endorse or promote products derived
  20  *       from this software without specific prior written permission.
  21  *
  22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdint.h>
  38 #include <sys/queue.h>
  39
  40 #include <rte_interrupts.h>
  41 #include <rte_pci.h>
  42 #include <rte_ethdev.h>
  43 #include <rte_devargs.h>
  44
  45 #include "test.h"
  46 #include "resource.h"
  47
  48 /* Generic maximum number of drivers to have room to allocate all drivers */
  49 #define NUM_MAX_DRIVERS 256
  50
  51 /*
  52  * PCI test
  53  * ========
  54  *
  55  * - Register a driver with a ``devinit()`` function.
  56  *
  57  * - Dump all PCI devices.
  58  *
  59  * - Check that the ``devinit()`` function is called at least once.
  60  */
  61
  62 int test_pci_run = 0; /* value checked by the multiprocess test */
  63 static unsigned pci_dev_count;
  64
  65 static int my_driver_init(struct rte_pci_driver *dr,
  66                           struct rte_pci_device *dev);
  67
  68 /* IXGBE NICS */
  69 struct rte_pci_id my_driver_id[] = {
  70         {RTE_PCI_DEVICE(0x0001, 0x1234)},
  71         { .vendor_id = 0, /* sentinel */ },
  72 };
  73
  74 struct rte_pci_id my_driver_id2[] = {
  75         {RTE_PCI_DEVICE(0x0001, 0x4444)},
  76         {RTE_PCI_DEVICE(0x0002, 0xabcd)},
  77         { .vendor_id = 0, /* sentinel */ },
  78 };
  79
  80 struct rte_pci_driver my_driver = {
  81         .name = "test_driver",
  82         .devinit = my_driver_init,
  83         .id_table = my_driver_id,
  84         .drv_flags = 0,
  85 };
  86
  87 struct rte_pci_driver my_driver2 = {
  88         .name = "test_driver2",
  89         .devinit = my_driver_init,
  90         .id_table = my_driver_id2,
  91         .drv_flags = 0,
  92 };
  93
  94 static int
  95 my_driver_init(__attribute__((unused)) struct rte_pci_driver *dr,
  96                struct rte_pci_device *dev)
  97 {
  98         printf("My driver init called in %s\n", dr->name);
  99         printf("%x:%x:%x.%d", dev->addr.domain, dev->addr.bus,
 100                dev->addr.devid, dev->addr.function);
 101         printf(" - vendor:%x device:%x\n", dev->id.vendor_id, dev->id.device_id);
 102
 103         pci_dev_count ++;
 104         return 0;
 105 }
 106
 107 static void
 108 blacklist_all_devices(void)
 109 {
 110         struct rte_pci_device *dev = NULL;
 111         unsigned i = 0;
 112         char pci_addr_str[16];
 113
 114         TAILQ_FOREACH(dev, &pci_device_list, next) {
 115                 snprintf(pci_addr_str, sizeof(pci_addr_str), PCI_PRI_FMT,
 116                         dev->addr.domain, dev->addr.bus, dev->addr.devid,
 117                         dev->addr.function);
 118                 if (rte_eal_devargs_add(RTE_DEVTYPE_BLACKLISTED_PCI,
 119                                 pci_addr_str) < 0) {
 120                         printf("Error: cannot blacklist <%s>", pci_addr_str);
 121                         break;
 122                 }
 123                 i++;
 124         }
 125         printf("%u devices blacklisted\n", i);
 126 }
 127
 128 /* clear devargs list that was modified by the test */
 129 static void free_devargs_list(void)
 130 {
 131         struct rte_devargs *devargs;
 132
 133         while (!TAILQ_EMPTY(&devargs_list)) {
 134                 devargs = TAILQ_FIRST(&devargs_list);
 135                 TAILQ_REMOVE(&devargs_list, devargs, next);
 136                 free(devargs->args);
 137                 free(devargs);
 138         }
 139 }
 140
 141 /* backup real devices & drivers (not used for testing) */
 142 struct pci_driver_list real_pci_driver_list =
 143         TAILQ_HEAD_INITIALIZER(real_pci_driver_list);
 144 struct pci_device_list real_pci_device_list =
 145         TAILQ_HEAD_INITIALIZER(real_pci_device_list);
 146
 147 REGISTER_LINKED_RESOURCE(test_pci_sysfs);
 148
 149 static int
 150 test_pci_setup(void)
 151 {
 152         struct rte_pci_device *dev;
 153         struct rte_pci_driver *dr;
 154         const struct resource *r;
 155         int ret;
 156
 157         r = resource_find("test_pci_sysfs");
 158         TEST_ASSERT_NOT_NULL(r, "missing resource test_pci_sysfs");
 159
 160         ret = resource_untar(r);
 161         TEST_ASSERT_SUCCESS(ret, "failed to untar %s", r->name);
 162
 163         ret = setenv("SYSFS_PCI_DEVICES", "test_pci_sysfs/bus/pci/devices", 1);
 164         TEST_ASSERT_SUCCESS(ret, "failed to setenv");
 165
 166         /* Unregister original devices & drivers lists */
 167         while (!TAILQ_EMPTY(&pci_driver_list)) {
 168                 dr = TAILQ_FIRST(&pci_driver_list);
 169                 rte_eal_pci_unregister(dr);
 170                 TAILQ_INSERT_TAIL(&real_pci_driver_list, dr, next);
 171         }
 172
 173         while (!TAILQ_EMPTY(&pci_device_list)) {
 174                 dev = TAILQ_FIRST(&pci_device_list);
 175                 TAILQ_REMOVE(&pci_device_list, dev, next);
 176                 TAILQ_INSERT_TAIL(&real_pci_device_list, dev, next);
 177         }
 178
 179         ret = rte_eal_pci_scan();
 180         TEST_ASSERT_SUCCESS(ret, "failed to scan PCI bus");
 181         rte_eal_pci_dump(stdout);
 182
 183         return 0;
 184 }
 185
 186 static int
 187 test_pci_cleanup(void)
 188 {
 189         struct rte_pci_device *dev;
 190         struct rte_pci_driver *dr;
 191         const struct resource *r;
 192         int ret;
 193
 194         unsetenv("SYSFS_PCI_DEVICES");
 195
 196         r = resource_find("test_pci_sysfs");
 197         TEST_ASSERT_NOT_NULL(r, "missing resource test_pci_sysfs");
 198
 199         ret = resource_rm_by_tar(r);
 200         TEST_ASSERT_SUCCESS(ret, "Failed to delete resource %s", r->name);
 201
 202         /*
 203          * FIXME: there is no API in DPDK to free a rte_pci_device so we
 204          * cannot free the devices in the right way. Let's assume that we
 205          * don't care for tests.
 206          */
 207         while (!TAILQ_EMPTY(&pci_device_list)) {
 208                 dev = TAILQ_FIRST(&pci_device_list);
 209                 TAILQ_REMOVE(&pci_device_list, dev, next);
 210         }
 211
 212         /* Restore original devices & drivers lists */
 213         while (!TAILQ_EMPTY(&real_pci_driver_list)) {
 214                 dr = TAILQ_FIRST(&real_pci_driver_list);
 215                 TAILQ_REMOVE(&real_pci_driver_list, dr, next);
 216                 rte_eal_pci_register(dr);
 217         }
 218
 219         while (!TAILQ_EMPTY(&real_pci_device_list)) {
 220                 dev = TAILQ_FIRST(&real_pci_device_list);
 221                 TAILQ_REMOVE(&real_pci_device_list, dev, next);
 222                 TAILQ_INSERT_TAIL(&pci_device_list, dev, next);
 223         }
 224
 225         return 0;
 226 }
 227
 228 static int
 229 test_pci_blacklist(void)
 230 {
 231         struct rte_devargs_list save_devargs_list;
 232
 233         printf("Dump all devices\n");
 234         TEST_ASSERT(TAILQ_EMPTY(&pci_driver_list),
 235                         "pci_driver_list not empty");
 236
 237         rte_eal_pci_register(&my_driver);
 238         rte_eal_pci_register(&my_driver2);
 239
 240         pci_dev_count = 0;
 241         printf("Scan bus\n");
 242         rte_eal_pci_probe();
 243
 244         if (pci_dev_count == 0) {
 245                 printf("no device detected\n");
 246                 return -1;
 247         }
 248
 249         /* save the real devargs_list */
 250         save_devargs_list = devargs_list;
 251         TAILQ_INIT(&devargs_list);
 252
 253         blacklist_all_devices();
 254
 255         pci_dev_count = 0;
 256         printf("Scan bus with all devices blacklisted\n");
 257         rte_eal_pci_probe();
 258
 259         free_devargs_list();
 260         devargs_list = save_devargs_list;
 261
 262         if (pci_dev_count != 0) {
 263                 printf("not all devices are blacklisted\n");
 264                 return -1;
 265         }
 266
 267         test_pci_run = 1;
 268
 269         rte_eal_pci_unregister(&my_driver);
 270         rte_eal_pci_unregister(&my_driver2);
 271
 272         return 0;
 273 }
 274
 275 static int test_pci_sysfs(void)
 276 {
 277         const char *orig;
 278         const char *newpath;
 279         int ret;
 280
 281         orig = pci_get_sysfs_path();
 282         ret = setenv("SYSFS_PCI_DEVICES", "My Documents", 1);
 283         TEST_ASSERT_SUCCESS(ret, "Failed setenv to My Documents");
 284
 285         newpath = pci_get_sysfs_path();
 286         TEST_ASSERT(!strcmp(newpath, "My Documents"),
 287                         "pci_get_sysfs_path() should return 'My Documents' "
 288                         "but gives %s", newpath);
 289
 290         ret = setenv("SYSFS_PCI_DEVICES", orig, 1);
 291         TEST_ASSERT_SUCCESS(ret, "Failed setenv back to '%s'", orig);
 292
 293         newpath = pci_get_sysfs_path();
 294         TEST_ASSERT(!strcmp(orig, newpath),
 295                         "pci_get_sysfs_path returned unexpected path: "
 296                         "%s (expected: %s)", newpath, orig);
 297         return 0;
 298 }
 299
 300 int
 301 test_pci(void)
 302 {
 303         if (test_pci_sysfs())
 304                 return -1;
 305
 306         if (test_pci_setup())
 307                 return -1;
 308
 309         if (test_pci_blacklist())
 310                 return -1;
 311
 312         if (test_pci_cleanup())
 313                 return -1;
 314
 315         return 0;
 316 }
 317
 318 REGISTER_TEST_COMMAND(pci_autotest, test_pci);