drivers/bus/vmbus/linux/vmbus_bus.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/mman.h>
  11 #include <sys/stat.h>
  12
  13 #include <rte_eal.h>
  14 #include <rte_uuid.h>
  15 #include <rte_tailq.h>
  16 #include <rte_log.h>
  17 #include <rte_devargs.h>
  18 #include <rte_memory.h>
  19 #include <rte_malloc.h>
  20 #include <rte_bus_vmbus.h>
  21
  22 #include "eal_filesystem.h"
  23 #include "private.h"
  24
  25 /** Pathname of VMBUS devices directory. */
  26 #define SYSFS_VMBUS_DEVICES "/sys/bus/vmbus/devices"
  27
  28 extern struct rte_vmbus_bus rte_vmbus_bus;
  29
  30 /* Read sysfs file to get UUID */
  31 static int
  32 parse_sysfs_uuid(const char *filename, rte_uuid_t uu)
  33 {
  34         char buf[BUFSIZ];
  35         char *cp, *in = buf;
  36         FILE *f;
  37
  38         f = fopen(filename, "r");
  39         if (f == NULL) {
  40                 VMBUS_LOG(ERR, "cannot open sysfs value %s: %s",
  41                           filename, strerror(errno));
  42                 return -1;
  43         }
  44
  45         if (fgets(buf, sizeof(buf), f) == NULL) {
  46                 VMBUS_LOG(ERR, "cannot read sysfs value %s",
  47                                 filename);
  48                 fclose(f);
  49                 return -1;
  50         }
  51         fclose(f);
  52
  53         cp = strchr(buf, '\n');
  54         if (cp)
  55                 *cp = '\0';
  56
  57         /* strip { } notation */
  58         if (buf[0] == '{') {
  59                 in = buf + 1;
  60                 cp = strchr(in, '}');
  61                 if (cp)
  62                         *cp = '\0';
  63         }
  64
  65         if (rte_uuid_parse(in, uu) < 0) {
  66                 VMBUS_LOG(ERR, "%s %s not a valid UUID",
  67                         filename, buf);
  68                 return -1;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static int
  75 get_sysfs_string(const char *filename, char *buf, size_t buflen)
  76 {
  77         char *cp;
  78         FILE *f;
  79
  80         f = fopen(filename, "r");
  81         if (f == NULL) {
  82                 VMBUS_LOG(ERR, "cannot open sysfs value %s:%s",
  83                           filename, strerror(errno));
  84                 return -1;
  85         }
  86
  87         if (fgets(buf, buflen, f) == NULL) {
  88                 VMBUS_LOG(ERR, "cannot read sysfs value %s",
  89                                 filename);
  90                 fclose(f);
  91                 return -1;
  92         }
  93         fclose(f);
  94
  95         /* remove trailing newline */
  96         cp = memchr(buf, '\n', buflen);
  97         if (cp)
  98                 *cp = '\0';
  99
 100         return 0;
 101 }
 102
 103 static int
 104 vmbus_get_uio_dev(const struct rte_vmbus_device *dev,
 105                   char *dstbuf, size_t buflen)
 106 {
 107         char dirname[PATH_MAX];
 108         unsigned int uio_num;
 109         struct dirent *e;
 110         DIR *dir;
 111
 112         /* Assume recent kernel where uio is in uio/uioX */
 113         snprintf(dirname, sizeof(dirname),
 114                  SYSFS_VMBUS_DEVICES "/%s/uio", dev->device.name);
 115
 116         dir = opendir(dirname);
 117         if (dir == NULL)
 118                 return -1; /* Not a UIO device */
 119
 120         /* take the first file starting with "uio" */
 121         while ((e = readdir(dir)) != NULL) {
 122                 const int prefix_len = 3;
 123                 char *endptr;
 124
 125                 if (strncmp(e->d_name, "uio", prefix_len) != 0)
 126                         continue;
 127
 128                 /* try uio%d */
 129                 errno = 0;
 130                 uio_num = strtoull(e->d_name + prefix_len, &endptr, 10);
 131                 if (errno == 0 && endptr != (e->d_name + prefix_len)) {
 132                         snprintf(dstbuf, buflen, "%s/uio%u", dirname, uio_num);
 133                         break;
 134                 }
 135         }
 136         closedir(dir);
 137
 138         if (e == NULL)
 139                 return -1;
 140
 141         return uio_num;
 142 }
 143
 144 /* Check map names with kernel names */
 145 static const char *map_names[VMBUS_MAX_RESOURCE] = {
 146         [HV_TXRX_RING_MAP] = "txrx_rings",
 147         [HV_INT_PAGE_MAP]  = "int_page",
 148         [HV_MON_PAGE_MAP]  = "monitor_page",
 149         [HV_RECV_BUF_MAP]  = "recv:",
 150         [HV_SEND_BUF_MAP]  = "send:",
 151 };
 152
 153
 154 /* map the resources of a vmbus device in virtual memory */
 155 int
 156 rte_vmbus_map_device(struct rte_vmbus_device *dev)
 157 {
 158         char uioname[PATH_MAX], filename[PATH_MAX];
 159         char dirname[PATH_MAX], mapname[64];
 160         int i;
 161
 162         dev->uio_num = vmbus_get_uio_dev(dev, uioname, sizeof(uioname));
 163         if (dev->uio_num < 0) {
 164                 VMBUS_LOG(DEBUG, "Not managed by UIO driver, skipped");
 165                 return 1;
 166         }
 167
 168         /* Extract resource value */
 169         for (i = 0; i < VMBUS_MAX_RESOURCE; i++) {
 170                 struct rte_mem_resource *res = &dev->resource[i];
 171                 unsigned long len, gpad = 0;
 172                 char *cp;
 173
 174                 snprintf(dirname, sizeof(dirname),
 175                          "%s/maps/map%d", uioname, i);
 176
 177                 snprintf(filename, sizeof(filename),
 178                          "%s/name", dirname);
 179
 180                 if (get_sysfs_string(filename, mapname, sizeof(mapname)) < 0) {
 181                         VMBUS_LOG(ERR, "could not read %s", filename);
 182                         return -1;
 183                 }
 184
 185                 if (strncmp(map_names[i], mapname, strlen(map_names[i])) != 0) {
 186                         VMBUS_LOG(ERR,
 187                                 "unexpected resource %s (expected %s)",
 188                                 mapname, map_names[i]);
 189                         return -1;
 190                 }
 191
 192                 snprintf(filename, sizeof(filename),
 193                          "%s/size", dirname);
 194                 if (eal_parse_sysfs_value(filename, &len) < 0) {
 195                         VMBUS_LOG(ERR,
 196                                 "could not read %s", filename);
 197                         return -1;
 198                 }
 199                 res->len = len;
 200
 201                 /* both send and receive buffers have gpad in name */
 202                 cp = memchr(mapname, ':', sizeof(mapname));
 203                 if (cp)
 204                         gpad = strtoul(cp+1, NULL, 0);
 205
 206                 /* put the GPAD value in physical address */
 207                 res->phys_addr = gpad;
 208         }
 209
 210         return vmbus_uio_map_resource(dev);
 211 }
 212
 213 void
 214 rte_vmbus_unmap_device(struct rte_vmbus_device *dev)
 215 {
 216         vmbus_uio_unmap_resource(dev);
 217 }
 218
 219 /* Scan one vmbus sysfs entry, and fill the devices list from it. */
 220 static int
 221 vmbus_scan_one(const char *name)
 222 {
 223         struct rte_vmbus_device *dev, *dev2;
 224         char filename[PATH_MAX];
 225         char dirname[PATH_MAX];
 226         unsigned long tmp;
 227
 228         dev = calloc(1, sizeof(*dev));
 229         if (dev == NULL)
 230                 return -1;
 231
 232         dev->device.bus = &rte_vmbus_bus.bus;
 233         dev->device.name = strdup(name);
 234         if (!dev->device.name)
 235                 goto error;
 236
 237         /* sysfs base directory
 238          *   /sys/bus/vmbus/devices/7a08391f-f5a0-4ac0-9802-d13fd964f8df
 239          * or on older kernel
 240          *   /sys/bus/vmbus/devices/vmbus_1
 241          */
 242         snprintf(dirname, sizeof(dirname), "%s/%s",
 243                  SYSFS_VMBUS_DEVICES, name);
 244
 245         /* get device id */
 246         snprintf(filename, sizeof(filename), "%s/device_id", dirname);
 247         if (parse_sysfs_uuid(filename, dev->device_id) < 0)
 248                 goto error;
 249
 250         /* get device class  */
 251         snprintf(filename, sizeof(filename), "%s/class_id", dirname);
 252         if (parse_sysfs_uuid(filename, dev->class_id) < 0)
 253                 goto error;
 254
 255         /* get relid */
 256         snprintf(filename, sizeof(filename), "%s/id", dirname);
 257         if (eal_parse_sysfs_value(filename, &tmp) < 0)
 258                 goto error;
 259         dev->relid = tmp;
 260
 261         /* get monitor id */
 262         snprintf(filename, sizeof(filename), "%s/monitor_id", dirname);
 263         if (eal_parse_sysfs_value(filename, &tmp) < 0)
 264                 goto error;
 265         dev->monitor_id = tmp;
 266
 267         /* get numa node (if present) */
 268         snprintf(filename, sizeof(filename), "%s/numa_node",
 269                  dirname);
 270
 271         if (access(filename, R_OK) == 0) {
 272                 if (eal_parse_sysfs_value(filename, &tmp) < 0)
 273                         goto error;
 274                 dev->device.numa_node = tmp;
 275         } else {
 276                 /* if no NUMA support, set default to 0 */
 277                 dev->device.numa_node = SOCKET_ID_ANY;
 278         }
 279
 280         dev->device.devargs = vmbus_devargs_lookup(dev);
 281
 282         /* device is valid, add in list (sorted) */
 283         VMBUS_LOG(DEBUG, "Adding vmbus device %s", name);
 284
 285         TAILQ_FOREACH(dev2, &rte_vmbus_bus.device_list, next) {
 286                 int ret;
 287
 288                 ret = rte_uuid_compare(dev->device_id, dev2->device_id);
 289                 if (ret > 0)
 290                         continue;
 291
 292                 if (ret < 0) {
 293                         vmbus_insert_device(dev2, dev);
 294                 } else { /* already registered */
 295                         VMBUS_LOG(NOTICE,
 296                                 "%s already registered", name);
 297                         free(dev);
 298                 }
 299                 return 0;
 300         }
 301
 302         vmbus_add_device(dev);
 303         return 0;
 304 error:
 305         VMBUS_LOG(DEBUG, "failed");
 306
 307         free(dev);
 308         return -1;
 309 }
 310
 311 /*
 312  * Scan the content of the vmbus, and the devices in the devices list
 313  */
 314 int
 315 rte_vmbus_scan(void)
 316 {
 317         struct dirent *e;
 318         DIR *dir;
 319
 320         dir = opendir(SYSFS_VMBUS_DEVICES);
 321         if (dir == NULL) {
 322                 if (errno == ENOENT)
 323                         return 0;
 324
 325                 VMBUS_LOG(ERR, "opendir %s failed: %s",
 326                           SYSFS_VMBUS_DEVICES, strerror(errno));
 327                 return -1;
 328         }
 329
 330         while ((e = readdir(dir)) != NULL) {
 331                 if (e->d_name[0] == '.')
 332                         continue;
 333
 334                 if (vmbus_scan_one(e->d_name) < 0)
 335                         goto error;
 336         }
 337         closedir(dir);
 338         return 0;
 339
 340 error:
 341         closedir(dir);
 342         return -1;
 343 }
 344
 345 void rte_vmbus_irq_mask(struct rte_vmbus_device *device)
 346 {
 347         vmbus_uio_irq_control(device, 1);
 348 }
 349
 350 void rte_vmbus_irq_unmask(struct rte_vmbus_device *device)
 351 {
 352         vmbus_uio_irq_control(device, 0);
 353 }
 354
 355 int rte_vmbus_irq_read(struct rte_vmbus_device *device)
 356 {
 357         return vmbus_uio_irq_read(device);
 358 }