src/loader/loader.c

   1 /*
   2  * Copyright (C) 2013 Rob Clark <robclark@freedesktop.org>
   3  * Copyright (C) 2014-2016 Emil Velikov <emil.l.velikov@gmail.com>
   4  * Copyright (C) 2016 Intel Corporation
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include <dlfcn.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <sys/stat.h>
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <stdbool.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <stdlib.h>
  39 #include <limits.h>
  40 #include <sys/param.h>
  41 #ifdef MAJOR_IN_MKDEV
  42 #include <sys/mkdev.h>
  43 #endif
  44 #ifdef MAJOR_IN_SYSMACROS
  45 #include <sys/sysmacros.h>
  46 #endif
  47 #include <GL/gl.h>
  48 #include <GL/internal/dri_interface.h>
  49 #include "loader.h"
  50
  51 #ifdef HAVE_LIBDRM
  52 #include <xf86drm.h>
  53 #define MAX_DRM_DEVICES 64
  54 #ifdef USE_DRICONF
  55 #include "util/xmlconfig.h"
  56 #include "util/driconf.h"
  57 #endif
  58 #endif
  59
  60 #include "util/macros.h"
  61
  62 #define __IS_LOADER
  63 #include "pci_id_driver_map.h"
  64
  65 /* For systems like Hurd */
  66 #ifndef PATH_MAX
  67 #define PATH_MAX 4096
  68 #endif
  69
  70 static void default_logger(int level, const char *fmt, ...)
  71 {
  72    if (level <= _LOADER_WARNING) {
  73       va_list args;
  74       va_start(args, fmt);
  75       vfprintf(stderr, fmt, args);
  76       va_end(args);
  77    }
  78 }
  79
  80 static loader_logger *log_ = default_logger;
  81
  82 int
  83 loader_open_device(const char *device_name)
  84 {
  85    int fd;
  86 #ifdef O_CLOEXEC
  87    fd = open(device_name, O_RDWR | O_CLOEXEC);
  88    if (fd == -1 && errno == EINVAL)
  89 #endif
  90    {
  91       fd = open(device_name, O_RDWR);
  92       if (fd != -1)
  93          fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
  94    }
  95    if (fd == -1 && errno == EACCES) {
  96       log_(_LOADER_WARNING, "failed to open %s: %s\n",
  97            device_name, strerror(errno));
  98    }
  99    return fd;
 100 }
 101
 102 static char *loader_get_kernel_driver_name(int fd)
 103 {
 104 #if HAVE_LIBDRM
 105    char *driver;
 106    drmVersionPtr version = drmGetVersion(fd);
 107
 108    if (!version) {
 109       log_(_LOADER_WARNING, "failed to get driver name for fd %d\n", fd);
 110       return NULL;
 111    }
 112
 113    driver = strndup(version->name, version->name_len);
 114    log_(driver ? _LOADER_DEBUG : _LOADER_WARNING, "using driver %s for %d\n",
 115         driver, fd);
 116
 117    drmFreeVersion(version);
 118    return driver;
 119 #else
 120    return NULL;
 121 #endif
 122 }
 123
 124 bool
 125 is_kernel_i915(int fd)
 126 {
 127    char *kernel_driver = loader_get_kernel_driver_name(fd);
 128    bool is_i915 = kernel_driver && strcmp(kernel_driver, "i915") == 0;
 129
 130    free(kernel_driver);
 131    return is_i915;
 132 }
 133
 134 #if defined(HAVE_LIBDRM)
 135 int
 136 loader_open_render_node(const char *name)
 137 {
 138    drmDevicePtr devices[MAX_DRM_DEVICES], device;
 139    int i, num_devices, fd = -1;
 140
 141    num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES);
 142    if (num_devices <= 0)
 143       return -ENOENT;
 144
 145    for (i = 0; i < num_devices; i++) {
 146       device = devices[i];
 147
 148       if ((device->available_nodes & (1 << DRM_NODE_RENDER)) &&
 149           (device->bustype == DRM_BUS_PLATFORM)) {
 150          drmVersionPtr version;
 151
 152          fd = loader_open_device(device->nodes[DRM_NODE_RENDER]);
 153          if (fd < 0)
 154             continue;
 155
 156          version = drmGetVersion(fd);
 157          if (!version) {
 158             close(fd);
 159             continue;
 160          }
 161
 162          if (strcmp(version->name, name) != 0) {
 163             drmFreeVersion(version);
 164             close(fd);
 165             continue;
 166          }
 167
 168          drmFreeVersion(version);
 169          break;
 170       }
 171    }
 172    drmFreeDevices(devices, num_devices);
 173
 174    if (i == num_devices)
 175       return -ENOENT;
 176
 177    return fd;
 178 }
 179
 180 #ifdef USE_DRICONF
 181 static const char __driConfigOptionsLoader[] =
 182 DRI_CONF_BEGIN
 183     DRI_CONF_SECTION_INITIALIZATION
 184         DRI_CONF_DEVICE_ID_PATH_TAG()
 185         DRI_CONF_DRI_DRIVER()
 186     DRI_CONF_SECTION_END
 187 DRI_CONF_END;
 188
 189 static char *loader_get_dri_config_driver(int fd)
 190 {
 191    driOptionCache defaultInitOptions;
 192    driOptionCache userInitOptions;
 193    char *dri_driver = NULL;
 194    char *kernel_driver = loader_get_kernel_driver_name(fd);
 195
 196    driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader);
 197    driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0,
 198                        "loader", kernel_driver, NULL, 0);
 199    if (driCheckOption(&userInitOptions, "dri_driver", DRI_STRING)) {
 200       char *opt = driQueryOptionstr(&userInitOptions, "dri_driver");
 201       /* not an empty string */
 202       if (*opt)
 203          dri_driver = strdup(opt);
 204    }
 205    driDestroyOptionCache(&userInitOptions);
 206    driDestroyOptionInfo(&defaultInitOptions);
 207
 208    free(kernel_driver);
 209    return dri_driver;
 210 }
 211
 212 static char *loader_get_dri_config_device_id(void)
 213 {
 214    driOptionCache defaultInitOptions;
 215    driOptionCache userInitOptions;
 216    char *prime = NULL;
 217
 218    driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader);
 219    driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0,
 220                        "loader", NULL, NULL, 0);
 221    if (driCheckOption(&userInitOptions, "device_id", DRI_STRING))
 222       prime = strdup(driQueryOptionstr(&userInitOptions, "device_id"));
 223    driDestroyOptionCache(&userInitOptions);
 224    driDestroyOptionInfo(&defaultInitOptions);
 225
 226    return prime;
 227 }
 228 #endif
 229
 230 static char *drm_construct_id_path_tag(drmDevicePtr device)
 231 {
 232    char *tag = NULL;
 233
 234    if (device->bustype == DRM_BUS_PCI) {
 235       if (asprintf(&tag, "pci-%04x_%02x_%02x_%1u",
 236                    device->businfo.pci->domain,
 237                    device->businfo.pci->bus,
 238                    device->businfo.pci->dev,
 239                    device->businfo.pci->func) < 0) {
 240          return NULL;
 241       }
 242    } else if (device->bustype == DRM_BUS_PLATFORM ||
 243               device->bustype == DRM_BUS_HOST1X) {
 244       char *fullname, *name, *address;
 245
 246       if (device->bustype == DRM_BUS_PLATFORM)
 247          fullname = device->businfo.platform->fullname;
 248       else
 249          fullname = device->businfo.host1x->fullname;
 250
 251       name = strrchr(fullname, '/');
 252       if (!name)
 253          name = strdup(fullname);
 254       else
 255          name = strdup(name + 1);
 256
 257       address = strchr(name, '@');
 258       if (address) {
 259          *address++ = '\0';
 260
 261          if (asprintf(&tag, "platform-%s_%s", address, name) < 0)
 262             tag = NULL;
 263       } else {
 264          if (asprintf(&tag, "platform-%s", name) < 0)
 265             tag = NULL;
 266       }
 267
 268       free(name);
 269    }
 270    return tag;
 271 }
 272
 273 static bool drm_device_matches_tag(drmDevicePtr device, const char *prime_tag)
 274 {
 275    char *tag = drm_construct_id_path_tag(device);
 276    int ret;
 277
 278    if (tag == NULL)
 279       return false;
 280
 281    ret = strcmp(tag, prime_tag);
 282
 283    free(tag);
 284    return ret == 0;
 285 }
 286
 287 static char *drm_get_id_path_tag_for_fd(int fd)
 288 {
 289    drmDevicePtr device;
 290    char *tag;
 291
 292    if (drmGetDevice2(fd, 0, &device) != 0)
 293        return NULL;
 294
 295    tag = drm_construct_id_path_tag(device);
 296    drmFreeDevice(&device);
 297    return tag;
 298 }
 299
 300 int loader_get_user_preferred_fd(int default_fd, bool *different_device)
 301 {
 302    const char *dri_prime = getenv("DRI_PRIME");
 303    char *default_tag, *prime = NULL;
 304    drmDevicePtr devices[MAX_DRM_DEVICES];
 305    int i, num_devices, fd = -1;
 306
 307    if (dri_prime)
 308       prime = strdup(dri_prime);
 309 #ifdef USE_DRICONF
 310    else
 311       prime = loader_get_dri_config_device_id();
 312 #endif
 313
 314    if (prime == NULL) {
 315       *different_device = false;
 316       return default_fd;
 317    }
 318
 319    default_tag = drm_get_id_path_tag_for_fd(default_fd);
 320    if (default_tag == NULL)
 321       goto err;
 322
 323    num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES);
 324    if (num_devices <= 0)
 325       goto err;
 326
 327    for (i = 0; i < num_devices; i++) {
 328       if (!(devices[i]->available_nodes & 1 << DRM_NODE_RENDER))
 329          continue;
 330
 331       /* two formats of DRI_PRIME are supported:
 332        * "1": choose any other card than the card used by default.
 333        * id_path_tag: (for example "pci-0000_02_00_0") choose the card
 334        * with this id_path_tag.
 335        */
 336       if (!strcmp(prime,"1")) {
 337          if (drm_device_matches_tag(devices[i], default_tag))
 338             continue;
 339       } else {
 340          if (!drm_device_matches_tag(devices[i], prime))
 341             continue;
 342       }
 343
 344       fd = loader_open_device(devices[i]->nodes[DRM_NODE_RENDER]);
 345       break;
 346    }
 347    drmFreeDevices(devices, num_devices);
 348
 349    if (i == num_devices)
 350       goto err;
 351
 352    if (fd < 0)
 353       goto err;
 354
 355    close(default_fd);
 356
 357    *different_device = !!strcmp(default_tag, prime);
 358
 359    free(default_tag);
 360    free(prime);
 361    return fd;
 362
 363  err:
 364    *different_device = false;
 365
 366    free(default_tag);
 367    free(prime);
 368    return default_fd;
 369 }
 370 #else
 371 int
 372 loader_open_render_node(const char *name)
 373 {
 374    return -1;
 375 }
 376
 377 int loader_get_user_preferred_fd(int default_fd, bool *different_device)
 378 {
 379    *different_device = false;
 380    return default_fd;
 381 }
 382 #endif
 383
 384 #if defined(HAVE_LIBDRM)
 385
 386 static bool
 387 drm_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id)
 388 {
 389    drmDevicePtr device;
 390
 391    if (drmGetDevice2(fd, 0, &device) != 0) {
 392       log_(_LOADER_WARNING, "MESA-LOADER: failed to retrieve device information\n");
 393       return false;
 394    }
 395
 396    if (device->bustype != DRM_BUS_PCI) {
 397       drmFreeDevice(&device);
 398       log_(_LOADER_DEBUG, "MESA-LOADER: device is not located on the PCI bus\n");
 399       return false;
 400    }
 401
 402    *vendor_id = device->deviceinfo.pci->vendor_id;
 403    *chip_id = device->deviceinfo.pci->device_id;
 404    drmFreeDevice(&device);
 405    return true;
 406 }
 407 #endif
 408
 409
 410 bool
 411 loader_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id)
 412 {
 413 #if HAVE_LIBDRM
 414    return drm_get_pci_id_for_fd(fd, vendor_id, chip_id);
 415 #endif
 416    return false;
 417 }
 418
 419 char *
 420 loader_get_device_name_for_fd(int fd)
 421 {
 422    char *result = NULL;
 423
 424 #if HAVE_LIBDRM
 425    result = drmGetDeviceNameFromFd2(fd);
 426 #endif
 427
 428    return result;
 429 }
 430
 431 static char *
 432 loader_get_pci_driver(int fd)
 433 {
 434    int vendor_id, chip_id, i, j;
 435    char *driver = NULL;
 436
 437    if (!loader_get_pci_id_for_fd(fd, &vendor_id, &chip_id))
 438       return NULL;
 439
 440    for (i = 0; i < ARRAY_SIZE(driver_map); i++) {
 441       if (vendor_id != driver_map[i].vendor_id)
 442          continue;
 443
 444       if (driver_map[i].predicate && !driver_map[i].predicate(fd))
 445          continue;
 446
 447       if (driver_map[i].num_chips_ids == -1) {
 448          driver = strdup(driver_map[i].driver);
 449          goto out;
 450       }
 451
 452       for (j = 0; j < driver_map[i].num_chips_ids; j++)
 453          if (driver_map[i].chip_ids[j] == chip_id) {
 454             driver = strdup(driver_map[i].driver);
 455             goto out;
 456          }
 457    }
 458
 459 out:
 460    log_(driver ? _LOADER_DEBUG : _LOADER_WARNING,
 461          "pci id for fd %d: %04x:%04x, driver %s\n",
 462          fd, vendor_id, chip_id, driver);
 463    return driver;
 464 }
 465
 466 char *
 467 loader_get_driver_for_fd(int fd)
 468 {
 469    char *driver;
 470
 471    /* Allow an environment variable to force choosing a different driver
 472     * binary.  If that driver binary can't survive on this FD, that's the
 473     * user's problem, but this allows vc4 simulator to run on an i965 host,
 474     * and may be useful for some touch testing of i915 on an i965 host.
 475     */
 476    if (geteuid() == getuid()) {
 477       driver = getenv("MESA_LOADER_DRIVER_OVERRIDE");
 478       if (driver)
 479          return strdup(driver);
 480    }
 481
 482 #if defined(HAVE_LIBDRM) && defined(USE_DRICONF)
 483    driver = loader_get_dri_config_driver(fd);
 484    if (driver)
 485       return driver;
 486 #endif
 487
 488    driver = loader_get_pci_driver(fd);
 489    if (!driver)
 490       driver = loader_get_kernel_driver_name(fd);
 491
 492    return driver;
 493 }
 494
 495 void
 496 loader_set_logger(loader_logger *logger)
 497 {
 498    log_ = logger;
 499 }
 500
 501 char *
 502 loader_get_extensions_name(const char *driver_name)
 503 {
 504    char *name = NULL;
 505
 506    if (asprintf(&name, "%s_%s", __DRI_DRIVER_GET_EXTENSIONS, driver_name) < 0)
 507       return NULL;
 508
 509    const size_t len = strlen(name);
 510    for (size_t i = 0; i < len; i++) {
 511       if (name[i] == '-')
 512          name[i] = '_';
 513    }
 514
 515    return name;
 516 }
 517
 518 /**
 519  * Opens a DRI driver using its driver name, returning the __DRIextension
 520  * entrypoints.
 521  *
 522  * \param driverName - a name like "i965", "radeon", "nouveau", etc.
 523  * \param out_driver - Address where the dlopen() return value will be stored.
 524  * \param search_path_vars - NULL-terminated list of env vars that can be used
 525  * to override the DEFAULT_DRIVER_DIR search path.
 526  */
 527 const struct __DRIextensionRec **
 528 loader_open_driver(const char *driver_name,
 529                    void **out_driver_handle,
 530                    const char **search_path_vars)
 531 {
 532    char path[PATH_MAX], *search_paths, *next, *end;
 533    char *get_extensions_name;
 534    const struct __DRIextensionRec **extensions = NULL;
 535    const struct __DRIextensionRec **(*get_extensions)(void);
 536
 537    search_paths = NULL;
 538    if (geteuid() == getuid() && search_path_vars) {
 539       for (int i = 0; search_path_vars[i] != NULL; i++) {
 540          search_paths = getenv(search_path_vars[i]);
 541          if (search_paths)
 542             break;
 543       }
 544    }
 545    if (search_paths == NULL)
 546       search_paths = DEFAULT_DRIVER_DIR;
 547
 548    void *driver = NULL;
 549    end = search_paths + strlen(search_paths);
 550    for (char *p = search_paths; p < end; p = next + 1) {
 551       int len;
 552       next = strchr(p, ':');
 553       if (next == NULL)
 554          next = end;
 555
 556       len = next - p;
 557 #if USE_ELF_TLS
 558       snprintf(path, sizeof(path), "%.*s/tls/%s_dri.so", len, p, driver_name);
 559       driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 560 #endif
 561       if (driver == NULL) {
 562          snprintf(path, sizeof(path), "%.*s/%s_dri.so", len, p, driver_name);
 563          driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 564          if (driver == NULL)
 565             log_(_LOADER_DEBUG, "MESA-LOADER: failed to open %s: %s\n",
 566                  path, dlerror());
 567       }
 568       /* not need continue to loop all paths once the driver is found */
 569       if (driver != NULL)
 570          break;
 571    }
 572
 573    if (driver == NULL) {
 574       log_(_LOADER_WARNING, "MESA-LOADER: failed to open %s (search paths %s)\n",
 575            driver_name, search_paths);
 576       *out_driver_handle = NULL;
 577       return NULL;
 578    }
 579
 580    log_(_LOADER_DEBUG, "MESA-LOADER: dlopen(%s)\n", path);
 581
 582    get_extensions_name = loader_get_extensions_name(driver_name);
 583    if (get_extensions_name) {
 584       get_extensions = dlsym(driver, get_extensions_name);
 585       if (get_extensions) {
 586          extensions = get_extensions();
 587       } else {
 588          log_(_LOADER_DEBUG, "MESA-LOADER: driver does not expose %s(): %s\n",
 589               get_extensions_name, dlerror());
 590       }
 591       free(get_extensions_name);
 592    }
 593
 594    if (!extensions)
 595       extensions = dlsym(driver, __DRI_DRIVER_EXTENSIONS);
 596    if (extensions == NULL) {
 597       log_(_LOADER_WARNING,
 598            "MESA-LOADER: driver exports no extensions (%s)\n", dlerror());
 599       dlclose(driver);
 600    }
 601
 602    *out_driver_handle = driver;
 603    return extensions;
 604 }