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/xmlpool.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
 115    drmFreeVersion(version);
 116    return driver;
 117 #else
 118    return NULL;
 119 #endif
 120 }
 121
 122 bool
 123 is_kernel_i915(int fd)
 124 {
 125    char *kernel_driver = loader_get_kernel_driver_name(fd);
 126    bool is_i915 = kernel_driver && strcmp(kernel_driver, "i915") == 0;
 127
 128    free(kernel_driver);
 129    return is_i915;
 130 }
 131
 132 #if defined(HAVE_LIBDRM)
 133 int
 134 loader_open_render_node(const char *name)
 135 {
 136    drmDevicePtr devices[MAX_DRM_DEVICES], device;
 137    int i, num_devices, fd = -1;
 138
 139    num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES);
 140    if (num_devices <= 0)
 141       return -ENOENT;
 142
 143    for (i = 0; i < num_devices; i++) {
 144       device = devices[i];
 145
 146       if ((device->available_nodes & (1 << DRM_NODE_RENDER)) &&
 147           (device->bustype == DRM_BUS_PLATFORM)) {
 148          drmVersionPtr version;
 149
 150          fd = loader_open_device(device->nodes[DRM_NODE_RENDER]);
 151          if (fd < 0)
 152             continue;
 153
 154          version = drmGetVersion(fd);
 155          if (!version) {
 156             close(fd);
 157             continue;
 158          }
 159
 160          if (strcmp(version->name, name) != 0) {
 161             drmFreeVersion(version);
 162             close(fd);
 163             continue;
 164          }
 165
 166          drmFreeVersion(version);
 167          break;
 168       }
 169    }
 170    drmFreeDevices(devices, num_devices);
 171
 172    if (i == num_devices)
 173       return -ENOENT;
 174
 175    return fd;
 176 }
 177
 178 #ifdef USE_DRICONF
 179 static const char __driConfigOptionsLoader[] =
 180 DRI_CONF_BEGIN
 181     DRI_CONF_SECTION_INITIALIZATION
 182         DRI_CONF_DEVICE_ID_PATH_TAG()
 183         DRI_CONF_DRI_DRIVER()
 184     DRI_CONF_SECTION_END
 185 DRI_CONF_END;
 186
 187 static char *loader_get_dri_config_driver(int fd)
 188 {
 189    driOptionCache defaultInitOptions;
 190    driOptionCache userInitOptions;
 191    char *dri_driver = NULL;
 192    char *kernel_driver = loader_get_kernel_driver_name(fd);
 193
 194    driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader);
 195    driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0,
 196                        "loader", kernel_driver, NULL, 0);
 197    if (driCheckOption(&userInitOptions, "dri_driver", DRI_STRING)) {
 198       char *opt = driQueryOptionstr(&userInitOptions, "dri_driver");
 199       /* not an empty string */
 200       if (*opt)
 201          dri_driver = strdup(opt);
 202    }
 203    driDestroyOptionCache(&userInitOptions);
 204    driDestroyOptionInfo(&defaultInitOptions);
 205
 206    free(kernel_driver);
 207    return dri_driver;
 208 }
 209
 210 static char *loader_get_dri_config_device_id(void)
 211 {
 212    driOptionCache defaultInitOptions;
 213    driOptionCache userInitOptions;
 214    char *prime = NULL;
 215
 216    driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader);
 217    driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0,
 218                        "loader", NULL, NULL, 0);
 219    if (driCheckOption(&userInitOptions, "device_id", DRI_STRING))
 220       prime = strdup(driQueryOptionstr(&userInitOptions, "device_id"));
 221    driDestroyOptionCache(&userInitOptions);
 222    driDestroyOptionInfo(&defaultInitOptions);
 223
 224    return prime;
 225 }
 226 #endif
 227
 228 static char *drm_construct_id_path_tag(drmDevicePtr device)
 229 {
 230    char *tag = NULL;
 231
 232    if (device->bustype == DRM_BUS_PCI) {
 233       if (asprintf(&tag, "pci-%04x_%02x_%02x_%1u",
 234                    device->businfo.pci->domain,
 235                    device->businfo.pci->bus,
 236                    device->businfo.pci->dev,
 237                    device->businfo.pci->func) < 0) {
 238          return NULL;
 239       }
 240    } else if (device->bustype == DRM_BUS_PLATFORM ||
 241               device->bustype == DRM_BUS_HOST1X) {
 242       char *fullname, *name, *address;
 243
 244       if (device->bustype == DRM_BUS_PLATFORM)
 245          fullname = device->businfo.platform->fullname;
 246       else
 247          fullname = device->businfo.host1x->fullname;
 248
 249       name = strrchr(fullname, '/');
 250       if (!name)
 251          name = strdup(fullname);
 252       else
 253          name = strdup(name + 1);
 254
 255       address = strchr(name, '@');
 256       if (address) {
 257          *address++ = '\0';
 258
 259          if (asprintf(&tag, "platform-%s_%s", address, name) < 0)
 260             tag = NULL;
 261       } else {
 262          if (asprintf(&tag, "platform-%s", name) < 0)
 263             tag = NULL;
 264       }
 265
 266       free(name);
 267    }
 268    return tag;
 269 }
 270
 271 static bool drm_device_matches_tag(drmDevicePtr device, const char *prime_tag)
 272 {
 273    char *tag = drm_construct_id_path_tag(device);
 274    int ret;
 275
 276    if (tag == NULL)
 277       return false;
 278
 279    ret = strcmp(tag, prime_tag);
 280
 281    free(tag);
 282    return ret == 0;
 283 }
 284
 285 static char *drm_get_id_path_tag_for_fd(int fd)
 286 {
 287    drmDevicePtr device;
 288    char *tag;
 289
 290    if (drmGetDevice2(fd, 0, &device) != 0)
 291        return NULL;
 292
 293    tag = drm_construct_id_path_tag(device);
 294    drmFreeDevice(&device);
 295    return tag;
 296 }
 297
 298 int loader_get_user_preferred_fd(int default_fd, bool *different_device)
 299 {
 300    const char *dri_prime = getenv("DRI_PRIME");
 301    char *default_tag, *prime = NULL;
 302    drmDevicePtr devices[MAX_DRM_DEVICES];
 303    int i, num_devices, fd = -1;
 304
 305    if (dri_prime)
 306       prime = strdup(dri_prime);
 307 #ifdef USE_DRICONF
 308    else
 309       prime = loader_get_dri_config_device_id();
 310 #endif
 311
 312    if (prime == NULL) {
 313       *different_device = false;
 314       return default_fd;
 315    }
 316
 317    default_tag = drm_get_id_path_tag_for_fd(default_fd);
 318    if (default_tag == NULL)
 319       goto err;
 320
 321    num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES);
 322    if (num_devices <= 0)
 323       goto err;
 324
 325    for (i = 0; i < num_devices; i++) {
 326       if (!(devices[i]->available_nodes & 1 << DRM_NODE_RENDER))
 327          continue;
 328
 329       /* two formats of DRI_PRIME are supported:
 330        * "1": choose any other card than the card used by default.
 331        * id_path_tag: (for example "pci-0000_02_00_0") choose the card
 332        * with this id_path_tag.
 333        */
 334       if (!strcmp(prime,"1")) {
 335          if (drm_device_matches_tag(devices[i], default_tag))
 336             continue;
 337       } else {
 338          if (!drm_device_matches_tag(devices[i], prime))
 339             continue;
 340       }
 341
 342       fd = loader_open_device(devices[i]->nodes[DRM_NODE_RENDER]);
 343       break;
 344    }
 345    drmFreeDevices(devices, num_devices);
 346
 347    if (i == num_devices)
 348       goto err;
 349
 350    if (fd < 0)
 351       goto err;
 352
 353    close(default_fd);
 354
 355    *different_device = !!strcmp(default_tag, prime);
 356
 357    free(default_tag);
 358    free(prime);
 359    return fd;
 360
 361  err:
 362    *different_device = false;
 363
 364    free(default_tag);
 365    free(prime);
 366    return default_fd;
 367 }
 368 #else
 369 int
 370 loader_open_render_node(const char *name)
 371 {
 372    return -1;
 373 }
 374
 375 int loader_get_user_preferred_fd(int default_fd, bool *different_device)
 376 {
 377    *different_device = false;
 378    return default_fd;
 379 }
 380 #endif
 381
 382 #if defined(HAVE_LIBDRM)
 383
 384 static bool
 385 drm_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id)
 386 {
 387    drmDevicePtr device;
 388
 389    if (drmGetDevice2(fd, 0, &device) != 0) {
 390       log_(_LOADER_WARNING, "MESA-LOADER: failed to retrieve device information\n");
 391       return false;
 392    }
 393
 394    if (device->bustype != DRM_BUS_PCI) {
 395       drmFreeDevice(&device);
 396       log_(_LOADER_DEBUG, "MESA-LOADER: device is not located on the PCI bus\n");
 397       return false;
 398    }
 399
 400    *vendor_id = device->deviceinfo.pci->vendor_id;
 401    *chip_id = device->deviceinfo.pci->device_id;
 402    drmFreeDevice(&device);
 403    return true;
 404 }
 405 #endif
 406
 407
 408 bool
 409 loader_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id)
 410 {
 411 #if HAVE_LIBDRM
 412    return drm_get_pci_id_for_fd(fd, vendor_id, chip_id);
 413 #endif
 414    return false;
 415 }
 416
 417 char *
 418 loader_get_device_name_for_fd(int fd)
 419 {
 420    char *result = NULL;
 421
 422 #if HAVE_LIBDRM
 423    result = drmGetDeviceNameFromFd2(fd);
 424 #endif
 425
 426    return result;
 427 }
 428
 429 char *
 430 loader_get_driver_for_fd(int fd)
 431 {
 432    int vendor_id, chip_id, i, j;
 433    char *driver = NULL;
 434
 435    /* Allow an environment variable to force choosing a different driver
 436     * binary.  If that driver binary can't survive on this FD, that's the
 437     * user's problem, but this allows vc4 simulator to run on an i965 host,
 438     * and may be useful for some touch testing of i915 on an i965 host.
 439     */
 440    if (geteuid() == getuid()) {
 441       driver = getenv("MESA_LOADER_DRIVER_OVERRIDE");
 442       if (driver)
 443          return strdup(driver);
 444    }
 445
 446 #if defined(HAVE_LIBDRM) && defined(USE_DRICONF)
 447    driver = loader_get_dri_config_driver(fd);
 448    if (driver)
 449       return driver;
 450 #endif
 451
 452    if (!loader_get_pci_id_for_fd(fd, &vendor_id, &chip_id)) {
 453       driver = loader_get_kernel_driver_name(fd);
 454       if (driver)
 455          log_(_LOADER_INFO, "using driver %s for %d\n", driver, fd);
 456       return driver;
 457    }
 458
 459    for (i = 0; i < ARRAY_SIZE(driver_map); i++) {
 460       if (vendor_id != driver_map[i].vendor_id)
 461          continue;
 462
 463       if (driver_map[i].predicate && !driver_map[i].predicate(fd))
 464          continue;
 465
 466       if (driver_map[i].num_chips_ids == -1) {
 467          driver = strdup(driver_map[i].driver);
 468          goto out;
 469       }
 470
 471       for (j = 0; j < driver_map[i].num_chips_ids; j++)
 472          if (driver_map[i].chip_ids[j] == chip_id) {
 473             driver = strdup(driver_map[i].driver);
 474             goto out;
 475          }
 476    }
 477
 478 out:
 479    log_(driver ? _LOADER_DEBUG : _LOADER_WARNING,
 480          "pci id for fd %d: %04x:%04x, driver %s\n",
 481          fd, vendor_id, chip_id, driver);
 482    return driver;
 483 }
 484
 485 void
 486 loader_set_logger(loader_logger *logger)
 487 {
 488    log_ = logger;
 489 }
 490
 491 char *
 492 loader_get_extensions_name(const char *driver_name)
 493 {
 494    char *name = NULL;
 495
 496    if (asprintf(&name, "%s_%s", __DRI_DRIVER_GET_EXTENSIONS, driver_name) < 0)
 497       return NULL;
 498
 499    const size_t len = strlen(name);
 500    for (size_t i = 0; i < len; i++) {
 501       if (name[i] == '-')
 502          name[i] = '_';
 503    }
 504
 505    return name;
 506 }
 507
 508 /**
 509  * Opens a DRI driver using its driver name, returning the __DRIextension
 510  * entrypoints.
 511  *
 512  * \param driverName - a name like "i965", "radeon", "nouveau", etc.
 513  * \param out_driver - Address where the dlopen() return value will be stored.
 514  * \param search_path_vars - NULL-terminated list of env vars that can be used
 515  * to override the DEFAULT_DRIVER_DIR search path.
 516  */
 517 const struct __DRIextensionRec **
 518 loader_open_driver(const char *driver_name,
 519                    void **out_driver_handle,
 520                    const char **search_path_vars)
 521 {
 522    char path[PATH_MAX], *search_paths, *next, *end;
 523    char *get_extensions_name;
 524    const struct __DRIextensionRec **extensions = NULL;
 525    const struct __DRIextensionRec **(*get_extensions)(void);
 526
 527    search_paths = NULL;
 528    if (geteuid() == getuid() && search_path_vars) {
 529       for (int i = 0; search_path_vars[i] != NULL; i++) {
 530          search_paths = getenv(search_path_vars[i]);
 531          if (search_paths)
 532             break;
 533       }
 534    }
 535    if (search_paths == NULL)
 536       search_paths = DEFAULT_DRIVER_DIR;
 537
 538    void *driver = NULL;
 539    end = search_paths + strlen(search_paths);
 540    for (char *p = search_paths; p < end; p = next + 1) {
 541       int len;
 542       next = strchr(p, ':');
 543       if (next == NULL)
 544          next = end;
 545
 546       len = next - p;
 547 #if USE_ELF_TLS
 548       snprintf(path, sizeof(path), "%.*s/tls/%s_dri.so", len, p, driver_name);
 549       driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 550 #endif
 551       if (driver == NULL) {
 552          snprintf(path, sizeof(path), "%.*s/%s_dri.so", len, p, driver_name);
 553          driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 554          if (driver == NULL)
 555             log_(_LOADER_DEBUG, "MESA-LOADER: failed to open %s: %s\n",
 556                  path, dlerror());
 557       }
 558       /* not need continue to loop all paths once the driver is found */
 559       if (driver != NULL)
 560          break;
 561    }
 562
 563    if (driver == NULL) {
 564       log_(_LOADER_WARNING, "MESA-LOADER: failed to open %s (search paths %s)\n",
 565            driver_name, search_paths);
 566       *out_driver_handle = NULL;
 567       return NULL;
 568    }
 569
 570    log_(_LOADER_DEBUG, "MESA-LOADER: dlopen(%s)\n", path);
 571
 572    get_extensions_name = loader_get_extensions_name(driver_name);
 573    if (get_extensions_name) {
 574       get_extensions = dlsym(driver, get_extensions_name);
 575       if (get_extensions) {
 576          extensions = get_extensions();
 577       } else {
 578          log_(_LOADER_DEBUG, "MESA-LOADER: driver does not expose %s(): %s\n",
 579               get_extensions_name, dlerror());
 580       }
 581       free(get_extensions_name);
 582    }
 583
 584    if (!extensions)
 585       extensions = dlsym(driver, __DRI_DRIVER_EXTENSIONS);
 586    if (extensions == NULL) {
 587       log_(_LOADER_WARNING,
 588            "MESA-LOADER: driver exports no extensions (%s)\n", dlerror());
 589       dlclose(driver);
 590    }
 591
 592    *out_driver_handle = driver;
 593    return extensions;
 594 }