drivers/bus/vmbus/vmbus_common.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (c) 2018, Microsoft Corporation.
   3  * All Rights Reserved.
   4  */
   5
   6 #include <string.h>
   7 #include <unistd.h>
   8 #include <dirent.h>
   9 #include <fcntl.h>
  10 #include <sys/queue.h>
  11 #include <sys/mman.h>
  12
  13 #include <rte_log.h>
  14 #include <rte_bus.h>
  15 #include <rte_eal.h>
  16 #include <rte_tailq.h>
  17 #include <rte_devargs.h>
  18 #include <rte_malloc.h>
  19 #include <rte_errno.h>
  20 #include <rte_memory.h>
  21 #include <rte_bus_vmbus.h>
  22
  23 #include "private.h"
  24
  25 int vmbus_logtype_bus;
  26 extern struct rte_vmbus_bus rte_vmbus_bus;
  27
  28 /* map a particular resource from a file */
  29 void *
  30 vmbus_map_resource(void *requested_addr, int fd, off_t offset, size_t size,
  31                    int flags)
  32 {
  33         void *mapaddr;
  34
  35         /* Map the memory resource of device */
  36         mapaddr = mmap(requested_addr, size, PROT_READ | PROT_WRITE,
  37                        MAP_SHARED | flags, fd, offset);
  38         if (mapaddr == MAP_FAILED) {
  39                 VMBUS_LOG(ERR,
  40                           "mmap(%d, %p, %zu, %ld) failed: %s",
  41                           fd, requested_addr, size, (long)offset,
  42                           strerror(errno));
  43         }
  44         return mapaddr;
  45 }
  46
  47 /* unmap a particular resource */
  48 void
  49 vmbus_unmap_resource(void *requested_addr, size_t size)
  50 {
  51         if (requested_addr == NULL)
  52                 return;
  53
  54         /* Unmap the VMBUS memory resource of device */
  55         if (munmap(requested_addr, size)) {
  56                 VMBUS_LOG(ERR, "munmap(%p, 0x%lx) failed: %s",
  57                         requested_addr, (unsigned long)size,
  58                         strerror(errno));
  59         } else
  60                 VMBUS_LOG(DEBUG, "  VMBUS memory unmapped at %p",
  61                           requested_addr);
  62 }
  63
  64 /**
  65  * Match the VMBUS driver and device using UUID table
  66  *
  67  * @param drv
  68  *      VMBUS driver from which ID table would be extracted
  69  * @param pci_dev
  70  *      VMBUS device to match against the driver
  71  * @return
  72  *      true for successful match
  73  *      false for unsuccessful match
  74  */
  75 static bool
  76 vmbus_match(const struct rte_vmbus_driver *dr,
  77             const struct rte_vmbus_device *dev)
  78 {
  79         const rte_uuid_t *id_table;
  80
  81         for (id_table = dr->id_table; !rte_uuid_is_null(*id_table); ++id_table) {
  82                 if (rte_uuid_compare(*id_table, dev->class_id) == 0)
  83                         return true;
  84         }
  85
  86         return false;
  87 }
  88 /*
  89  * If device ID match, call the devinit() function of the driver.
  90  */
  91 static int
  92 vmbus_probe_one_driver(struct rte_vmbus_driver *dr,
  93                        struct rte_vmbus_device *dev)
  94 {
  95         char guid[RTE_UUID_STRLEN];
  96         int ret;
  97
  98         if (!vmbus_match(dr, dev))
  99                 return 1;        /* not supported */
 100
 101         rte_uuid_unparse(dev->device_id, guid, sizeof(guid));
 102         VMBUS_LOG(INFO, "VMBUS device %s on NUMA socket %i",
 103                   guid, dev->device.numa_node);
 104
 105         /* TODO add blacklisted */
 106
 107         /* map resources for device */
 108         ret = rte_vmbus_map_device(dev);
 109         if (ret != 0)
 110                 return ret;
 111
 112         /* reference driver structure */
 113         dev->driver = dr;
 114
 115         if (dev->device.numa_node < 0) {
 116                 VMBUS_LOG(WARNING, "  Invalid NUMA socket, default to 0");
 117                 dev->device.numa_node = 0;
 118         }
 119
 120         /* call the driver probe() function */
 121         VMBUS_LOG(INFO, "  probe driver: %s", dr->driver.name);
 122         ret = dr->probe(dr, dev);
 123         if (ret) {
 124                 dev->driver = NULL;
 125                 rte_vmbus_unmap_device(dev);
 126         } else {
 127                 dev->device.driver = &dr->driver;
 128         }
 129
 130         return ret;
 131 }
 132
 133 /*
 134  * IF device class GUID mathces, call the probe function of
 135  * registere drivers for the vmbus device.
 136  * Return -1 if initialization failed,
 137  * and 1 if no driver found for this device.
 138  */
 139 static int
 140 vmbus_probe_all_drivers(struct rte_vmbus_device *dev)
 141 {
 142         struct rte_vmbus_driver *dr;
 143         int rc;
 144
 145         /* Check if a driver is already loaded */
 146         if (rte_dev_is_probed(&dev->device)) {
 147                 VMBUS_LOG(DEBUG, "VMBUS driver already loaded");
 148                 return 0;
 149         }
 150
 151         FOREACH_DRIVER_ON_VMBUS(dr) {
 152                 rc = vmbus_probe_one_driver(dr, dev);
 153                 if (rc < 0) /* negative is an error */
 154                         return -1;
 155
 156                 if (rc > 0) /* positive driver doesn't support it */
 157                         continue;
 158
 159                 return 0;
 160         }
 161         return 1;
 162 }
 163
 164 /*
 165  * Scan the vmbus, and call the devinit() function for
 166  * all registered drivers that have a matching entry in its id_table
 167  * for discovered devices.
 168  */
 169 int
 170 rte_vmbus_probe(void)
 171 {
 172         struct rte_vmbus_device *dev;
 173         size_t probed = 0, failed = 0;
 174         char ubuf[RTE_UUID_STRLEN];
 175
 176         FOREACH_DEVICE_ON_VMBUS(dev) {
 177                 probed++;
 178
 179                 rte_uuid_unparse(dev->device_id, ubuf, sizeof(ubuf));
 180
 181                 /* TODO: add whitelist/blacklist */
 182
 183                 if (vmbus_probe_all_drivers(dev) < 0) {
 184                         VMBUS_LOG(NOTICE,
 185                                 "Requested device %s cannot be used", ubuf);
 186                         rte_errno = errno;
 187                         failed++;
 188                 }
 189         }
 190
 191         return (probed && probed == failed) ? -1 : 0;
 192 }
 193
 194 static int
 195 vmbus_parse(const char *name, void *addr)
 196 {
 197         rte_uuid_t guid;
 198         int ret;
 199
 200         ret = rte_uuid_parse(name, guid);
 201         if (ret == 0 && addr)
 202                 memcpy(addr, &guid, sizeof(guid));
 203
 204         return ret;
 205 }
 206
 207 /*
 208  * scan for matching device args on command line
 209  * example:
 210  *      -w 'vmbus:635a7ae3-091e-4410-ad59-667c4f8c04c3,latency=20'
 211  */
 212 struct rte_devargs *
 213 vmbus_devargs_lookup(struct rte_vmbus_device *dev)
 214 {
 215         struct rte_devargs *devargs;
 216         rte_uuid_t addr;
 217
 218         RTE_EAL_DEVARGS_FOREACH("vmbus", devargs) {
 219                 vmbus_parse(devargs->name, &addr);
 220
 221                 if (rte_uuid_compare(dev->device_id, addr) == 0)
 222                         return devargs;
 223         }
 224         return NULL;
 225
 226 }
 227
 228 /* register vmbus driver */
 229 void
 230 rte_vmbus_register(struct rte_vmbus_driver *driver)
 231 {
 232         VMBUS_LOG(DEBUG,
 233                 "Registered driver %s", driver->driver.name);
 234
 235         TAILQ_INSERT_TAIL(&rte_vmbus_bus.driver_list, driver, next);
 236         driver->bus = &rte_vmbus_bus;
 237 }
 238
 239 /* unregister vmbus driver */
 240 void
 241 rte_vmbus_unregister(struct rte_vmbus_driver *driver)
 242 {
 243         TAILQ_REMOVE(&rte_vmbus_bus.driver_list, driver, next);
 244         driver->bus = NULL;
 245 }
 246
 247 /* Add a device to VMBUS bus */
 248 void
 249 vmbus_add_device(struct rte_vmbus_device *vmbus_dev)
 250 {
 251         TAILQ_INSERT_TAIL(&rte_vmbus_bus.device_list, vmbus_dev, next);
 252 }
 253
 254 /* Insert a device into a predefined position in VMBUS bus */
 255 void
 256 vmbus_insert_device(struct rte_vmbus_device *exist_vmbus_dev,
 257                       struct rte_vmbus_device *new_vmbus_dev)
 258 {
 259         TAILQ_INSERT_BEFORE(exist_vmbus_dev, new_vmbus_dev, next);
 260 }
 261
 262 /* Remove a device from VMBUS bus */
 263 void
 264 vmbus_remove_device(struct rte_vmbus_device *vmbus_dev)
 265 {
 266         TAILQ_REMOVE(&rte_vmbus_bus.device_list, vmbus_dev, next);
 267 }
 268
 269 /* VMBUS doesn't support hotplug */
 270 static struct rte_device *
 271 vmbus_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
 272                   const void *data)
 273 {
 274         struct rte_vmbus_device *dev;
 275
 276         FOREACH_DEVICE_ON_VMBUS(dev) {
 277                 if (start && &dev->device == start) {
 278                         start = NULL;
 279                         continue;
 280                 }
 281                 if (cmp(&dev->device, data) == 0)
 282                         return &dev->device;
 283         }
 284
 285         return NULL;
 286 }
 287
 288
 289 struct rte_vmbus_bus rte_vmbus_bus = {
 290         .bus = {
 291                 .scan = rte_vmbus_scan,
 292                 .probe = rte_vmbus_probe,
 293                 .find_device = vmbus_find_device,
 294                 .parse = vmbus_parse,
 295         },
 296         .device_list = TAILQ_HEAD_INITIALIZER(rte_vmbus_bus.device_list),
 297         .driver_list = TAILQ_HEAD_INITIALIZER(rte_vmbus_bus.driver_list),
 298 };
 299
 300 RTE_REGISTER_BUS(vmbus, rte_vmbus_bus.bus);
 301
 302 RTE_INIT(vmbus_init_log)
 303 {
 304         vmbus_logtype_bus = rte_log_register("bus.vmbus");
 305         if (vmbus_logtype_bus >= 0)
 306                 rte_log_set_level(vmbus_logtype_bus, RTE_LOG_NOTICE);
 307 }