| /* | |
| * Copyright (C) 2013 Rob Clark <robclark@freedesktop.org> | |
| * Copyright (C) 2014-2016 Emil Velikov <emil.l.velikov@gmail.com> | |
| * Copyright (C) 2016 Intel Corporation | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice (including the next | |
| * paragraph) shall be included in all copies or substantial portions of the | |
| * Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
| * SOFTWARE. | |
| * | |
| * Authors: | |
| * Rob Clark <robclark@freedesktop.org> | |
| */ | |
| #include <dlfcn.h> | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <sys/stat.h> | |
| #include <stdarg.h> | |
| #include <stdio.h> | |
| #include <stdbool.h> | |
| #include <string.h> | |
| #include <unistd.h> | |
| #include <stdlib.h> | |
| #include <limits.h> | |
| #include <sys/param.h> | |
| #ifdef MAJOR_IN_MKDEV | |
| #include <sys/mkdev.h> | |
| #endif | |
| #ifdef MAJOR_IN_SYSMACROS | |
| #include <sys/sysmacros.h> | |
| #endif | |
| #include <GL/gl.h> | |
| #include "mesa_interface.h" | |
| #include "loader.h" | |
| #include "util/drm_is_nouveau.h" | |
| #include "util/libdrm.h" | |
| #include "util/os_file.h" | |
| #include "util/os_misc.h" | |
| #include "util/u_debug.h" | |
| #include "git_sha1.h" | |
| #include "drm-uapi/nouveau_drm.h" | |
| #define MAX_DRM_DEVICES 64 | |
| #ifdef USE_DRICONF | |
| #include "util/xmlconfig.h" | |
| #include "util/driconf.h" | |
| #endif | |
| #include "util/macros.h" | |
| #define __IS_LOADER | |
| #include "pci_id_driver_map.h" | |
| /* For systems like Hurd */ | |
| #ifndef PATH_MAX | |
| #define PATH_MAX 4096 | |
| #endif | |
| static void default_logger(int level, const char *fmt, ...) | |
| { | |
| if (level <= _LOADER_WARNING) { | |
| va_list args; | |
| va_start(args, fmt); | |
| vfprintf(stderr, fmt, args); | |
| va_end(args); | |
| } | |
| } | |
| static loader_logger *log_ = default_logger; | |
| int | |
| loader_open_device(const char *device_name) | |
| { | |
| int fd; | |
| #ifdef O_CLOEXEC | |
| fd = open(device_name, O_RDWR | O_CLOEXEC); | |
| if (fd == -1 && errno == EINVAL) | |
| #endif | |
| { | |
| fd = open(device_name, O_RDWR); | |
| if (fd != -1) | |
| fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC); | |
| } | |
| if (fd == -1 && errno == EACCES) { | |
| log_(_LOADER_WARNING, "failed to open %s: %s\n", | |
| device_name, strerror(errno)); | |
| } | |
| return fd; | |
| } | |
| char * | |
| loader_get_kernel_driver_name(int fd) | |
| { | |
| char *driver; | |
| drmVersionPtr version = drmGetVersion(fd); | |
| if (!version) { | |
| log_(_LOADER_WARNING, "failed to get driver name for fd %d\n", fd); | |
| return NULL; | |
| } | |
| driver = strndup(version->name, version->name_len); | |
| log_(driver ? _LOADER_DEBUG : _LOADER_WARNING, "using driver %s for %d\n", | |
| driver, fd); | |
| drmFreeVersion(version); | |
| return driver; | |
| } | |
| bool | |
| amd_predicate(int fd, const char *driver) | |
| { | |
| char *kernel_driver = loader_get_kernel_driver_name(fd); | |
| bool ret = kernel_driver && | |
| (strcmp(kernel_driver, "amdgpu") == 0 || strcmp(kernel_driver, "radeon") == 0); | |
| free(kernel_driver); | |
| return ret; | |
| } | |
| bool | |
| iris_predicate(int fd, const char *driver) | |
| { | |
| char *kernel_driver = loader_get_kernel_driver_name(fd); | |
| bool ret = kernel_driver && (strcmp(kernel_driver, "i915") == 0 || | |
| strcmp(kernel_driver, "xe") == 0); | |
| free(kernel_driver); | |
| return ret; | |
| } | |
| /* choose zink or nouveau GL */ | |
| bool | |
| nouveau_zink_predicate(int fd, const char *driver) | |
| { | |
| #ifndef HAVE_LIBDRM | |
| return true; | |
| #else | |
| /* Never load on nv proprietary driver */ | |
| if (!drm_fd_is_nouveau(fd)) | |
| return false; | |
| bool prefer_zink = false; | |
| bool require_zink = false; | |
| /* Enable Zink by default on Turing and later GPUs | |
| * | |
| * We only use Zink if if the kernel supports VMA_TILEMODE, which is needed | |
| * for DRM format modifiers. This also doubles as a check for a new enough | |
| * kernel to run NVK in general. | |
| */ | |
| struct drm_nouveau_getparam r = { .param = NOUVEAU_GETPARAM_HAS_VMA_TILEMODE }; | |
| int ret = drmCommandWriteRead(fd, DRM_NOUVEAU_GETPARAM, &r, sizeof(r)); | |
| if (ret == 0 && r.value == 1) { | |
| r.param = NOUVEAU_GETPARAM_CHIPSET_ID; | |
| r.value = 0; | |
| ret = drmCommandWriteRead(fd, DRM_NOUVEAU_GETPARAM, &r, sizeof(r)); | |
| if (ret == 0 && r.value >= 0x160) { | |
| prefer_zink = true; | |
| } | |
| /* Nouveau GL isn't enabled on anything after Ada */ | |
| if (ret == 0 && r.value >= 0x1a0) { | |
| require_zink = true; | |
| } | |
| } | |
| assert(!require_zink || prefer_zink); | |
| prefer_zink = debug_get_bool_option("NOUVEAU_USE_ZINK", prefer_zink); | |
| bool use_zink = prefer_zink; | |
| if (require_zink) { | |
| /* nouveau_zink_predicate() typically gets called twice but we only want | |
| * to warn once. | |
| */ | |
| static bool warned = false; | |
| if (!prefer_zink && !warned) { | |
| log_(_LOADER_WARNING, | |
| "NOUVEAU_USE_ZINK is ignored for Blackwell and later GPUs.\n"); | |
| warned = true; | |
| } | |
| use_zink = true; | |
| } | |
| if (use_zink && !strcmp(driver, "zink")) | |
| return true; | |
| if (!use_zink && !strcmp(driver, "nouveau")) | |
| return true; | |
| return false; | |
| #endif | |
| } | |
| /** | |
| * Goes through all the platform devices whose driver is on the given list and | |
| * try to open their render node. It returns the fd of the first device that | |
| * it can open. | |
| */ | |
| int | |
| loader_open_render_node_platform_device(const char * const drivers[], | |
| unsigned int n_drivers) | |
| { | |
| unsigned int n_devices; | |
| int *fds = loader_open_render_node_platform_devices(drivers, n_drivers, &n_devices); | |
| int fd = -1; | |
| if (n_devices > 0) { | |
| fd = fds[0]; | |
| free(fds); | |
| } | |
| return fd; | |
| } | |
| /** | |
| * Goes through all the platform devices whose driver is on the given list and | |
| * try to open their render node. It returns an array with the fds of all the | |
| * devices that it can open. | |
| * | |
| * Caller must close the returned fds and free the array. | |
| */ | |
| int * | |
| loader_open_render_node_platform_devices(const char * const drivers[], | |
| unsigned int n_drivers, | |
| unsigned int *n_devices) | |
| { | |
| drmDevicePtr devices[MAX_DRM_DEVICES], device; | |
| int num_devices, fd = -1; | |
| int i, j; | |
| int *result; | |
| num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES); | |
| if (num_devices <= 0) { | |
| *n_devices = 0; | |
| return NULL; | |
| } | |
| result = calloc(num_devices, sizeof(int)); | |
| *n_devices = 0; | |
| for (i = 0; i < num_devices; i++) { | |
| device = devices[i]; | |
| if ((device->available_nodes & (1 << DRM_NODE_RENDER)) && | |
| (device->bustype == DRM_BUS_PLATFORM)) { | |
| drmVersionPtr version; | |
| bool found = false; | |
| fd = loader_open_device(device->nodes[DRM_NODE_RENDER]); | |
| if (fd < 0) | |
| continue; | |
| version = drmGetVersion(fd); | |
| if (!version) { | |
| close(fd); | |
| continue; | |
| } | |
| for (j = 0; j < n_drivers; j++) { | |
| /* Always try to open the render device with Zink if requested */ | |
| if (strcmp("zink", drivers[j]) == 0 || | |
| strcmp(version->name, drivers[j]) == 0) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| drmFreeVersion(version); | |
| if (found) | |
| result[(*n_devices)++] = fd; | |
| else | |
| close(fd); | |
| } | |
| } | |
| drmFreeDevices(devices, num_devices); | |
| if (*n_devices == 0) { | |
| free(result); | |
| return NULL; | |
| } | |
| return result; | |
| } | |
| bool | |
| loader_is_device_render_capable(int fd) | |
| { | |
| drmDevicePtr dev_ptr; | |
| bool ret; | |
| if (drmGetDevice2(fd, 0, &dev_ptr) != 0) | |
| return false; | |
| ret = (dev_ptr->available_nodes & (1 << DRM_NODE_RENDER)); | |
| drmFreeDevice(&dev_ptr); | |
| return ret; | |
| } | |
| char * | |
| loader_get_render_node(dev_t device) | |
| { | |
| char *render_node = NULL; | |
| drmDevicePtr dev_ptr; | |
| if (drmGetDeviceFromDevId(device, 0, &dev_ptr) < 0) | |
| return NULL; | |
| if (dev_ptr->available_nodes & (1 << DRM_NODE_RENDER)) { | |
| render_node = strdup(dev_ptr->nodes[DRM_NODE_RENDER]); | |
| if (!render_node) | |
| log_(_LOADER_DEBUG, "MESA-LOADER: failed to allocate memory for render node\n"); | |
| } | |
| drmFreeDevice(&dev_ptr); | |
| return render_node; | |
| } | |
| #ifdef USE_DRICONF | |
| static const driOptionDescription __driConfigOptionsLoader[] = { | |
| DRI_CONF_SECTION_INITIALIZATION | |
| DRI_CONF_DEVICE_ID_PATH_TAG() | |
| DRI_CONF_DRI_DRIVER() | |
| DRI_CONF_SECTION_END | |
| }; | |
| static char *loader_get_dri_config_driver(int fd) | |
| { | |
| driOptionCache defaultInitOptions; | |
| driOptionCache userInitOptions; | |
| char *dri_driver = NULL; | |
| char *kernel_driver = loader_get_kernel_driver_name(fd); | |
| driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader, | |
| ARRAY_SIZE(__driConfigOptionsLoader)); | |
| driParseConfigFiles(&userInitOptions, &defaultInitOptions, | |
| &(driConfigFileParseParams) { | |
| .driverName = "loader", | |
| .kernelDriverName = kernel_driver, | |
| }); | |
| if (driCheckOption(&userInitOptions, "dri_driver", DRI_STRING)) { | |
| char *opt = driQueryOptionstr(&userInitOptions, "dri_driver"); | |
| /* not an empty string */ | |
| if (*opt) | |
| dri_driver = strdup(opt); | |
| } | |
| driDestroyOptionCache(&userInitOptions); | |
| driDestroyOptionInfo(&defaultInitOptions); | |
| free(kernel_driver); | |
| return dri_driver; | |
| } | |
| static char *loader_get_dri_config_device_id(void) | |
| { | |
| driOptionCache defaultInitOptions; | |
| driOptionCache userInitOptions; | |
| char *prime = NULL; | |
| driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader, | |
| ARRAY_SIZE(__driConfigOptionsLoader)); | |
| driParseConfigFiles(&userInitOptions, &defaultInitOptions, | |
| &(driConfigFileParseParams) { | |
| .driverName = "loader", | |
| }); | |
| if (driCheckOption(&userInitOptions, "device_id", DRI_STRING)) { | |
| char *opt = driQueryOptionstr(&userInitOptions, "device_id"); | |
| if (*opt) | |
| prime = strdup(opt); | |
| } | |
| driDestroyOptionCache(&userInitOptions); | |
| driDestroyOptionInfo(&defaultInitOptions); | |
| return prime; | |
| } | |
| #endif | |
| static char *drm_construct_id_path_tag(drmDevicePtr device) | |
| { | |
| char *tag = NULL; | |
| if (device->bustype == DRM_BUS_PCI) { | |
| if (asprintf(&tag, "pci-%04x_%02x_%02x_%1u", | |
| device->businfo.pci->domain, | |
| device->businfo.pci->bus, | |
| device->businfo.pci->dev, | |
| device->businfo.pci->func) < 0) { | |
| return NULL; | |
| } | |
| } else if (device->bustype == DRM_BUS_PLATFORM || | |
| device->bustype == DRM_BUS_HOST1X) { | |
| char *fullname, *name, *address; | |
| if (device->bustype == DRM_BUS_PLATFORM) | |
| fullname = device->businfo.platform->fullname; | |
| else | |
| fullname = device->businfo.host1x->fullname; | |
| name = strrchr(fullname, '/'); | |
| if (!name) | |
| name = strdup(fullname); | |
| else | |
| name = strdup(name + 1); | |
| address = strchr(name, '@'); | |
| if (address) { | |
| *address++ = '\0'; | |
| if (asprintf(&tag, "platform-%s_%s", address, name) < 0) | |
| tag = NULL; | |
| } else { | |
| if (asprintf(&tag, "platform-%s", name) < 0) | |
| tag = NULL; | |
| } | |
| free(name); | |
| } | |
| return tag; | |
| } | |
| static bool drm_device_matches_tag(drmDevicePtr device, const char *prime_tag) | |
| { | |
| char *tag = drm_construct_id_path_tag(device); | |
| int ret; | |
| if (tag == NULL) | |
| return false; | |
| ret = strcmp(tag, prime_tag); | |
| free(tag); | |
| return ret == 0; | |
| } | |
| static char *drm_get_id_path_tag_for_fd(int fd) | |
| { | |
| drmDevicePtr device; | |
| char *tag; | |
| if (drmGetDevice2(fd, 0, &device) != 0) | |
| return NULL; | |
| tag = drm_construct_id_path_tag(device); | |
| drmFreeDevice(&device); | |
| return tag; | |
| } | |
| bool loader_drm_devices_match(drmDevicePtr dev1, drmDevicePtr dev2) | |
| { | |
| char *tag = drm_construct_id_path_tag(dev1); | |
| bool ret = drm_device_matches_tag(dev2, tag); | |
| free(tag); | |
| return ret; | |
| } | |
| bool loader_get_user_preferred_device(drmDevicePtr default_dev, drmDevicePtr *preferred_dev) | |
| { | |
| const char *dri_prime = os_get_option("DRI_PRIME"); | |
| bool debug = debug_get_bool_option("DRI_PRIME_DEBUG", false); | |
| drmDevicePtr devices[MAX_DRM_DEVICES]; | |
| int i, num_devices = -1; | |
| struct { | |
| enum { | |
| PRIME_IS_INTEGER, | |
| PRIME_IS_VID_DID, | |
| PRIME_IS_PCI_TAG | |
| } semantics; | |
| union { | |
| int as_integer; | |
| struct { | |
| uint16_t v, d; | |
| } as_vendor_device_ids; | |
| } v; | |
| char *str; | |
| } prime = {}; | |
| prime.str = NULL; | |
| if (dri_prime) | |
| prime.str = strdup(dri_prime); | |
| #ifdef USE_DRICONF | |
| else | |
| prime.str = loader_get_dri_config_device_id(); | |
| #endif | |
| if (prime.str == NULL) { | |
| goto no_prime_gpu_offloading; | |
| } else { | |
| uint16_t vendor_id, device_id; | |
| if (sscanf(prime.str, "%hx:%hx", &vendor_id, &device_id) == 2) { | |
| prime.semantics = PRIME_IS_VID_DID; | |
| prime.v.as_vendor_device_ids.v = vendor_id; | |
| prime.v.as_vendor_device_ids.d = device_id; | |
| } else { | |
| int i = atoi(prime.str); | |
| if (i < 0 || strcmp(prime.str, "0") == 0) { | |
| printf("Invalid value (%d) for DRI_PRIME. Should be > 0\n", i); | |
| goto err; | |
| } else if (i == 0) { | |
| prime.semantics = PRIME_IS_PCI_TAG; | |
| } else { | |
| prime.semantics = PRIME_IS_INTEGER; | |
| prime.v.as_integer = i; | |
| } | |
| } | |
| } | |
| num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES); | |
| if (num_devices <= 0) | |
| goto err; | |
| if (debug) { | |
| log_(_LOADER_WARNING, "DRI_PRIME: %d devices\n", num_devices); | |
| for (i = 0; i < num_devices; i++) { | |
| log_(_LOADER_WARNING, " %d:", i); | |
| if (!(devices[i]->available_nodes & 1 << DRM_NODE_RENDER)) { | |
| log_(_LOADER_WARNING, "not a render node -> not usable\n"); | |
| continue; | |
| } | |
| char *tag = drm_construct_id_path_tag(devices[i]); | |
| if (tag) { | |
| log_(_LOADER_WARNING, " %s", tag); | |
| free(tag); | |
| } | |
| if (devices[i]->bustype == DRM_BUS_PCI) { | |
| log_(_LOADER_WARNING, " %4x:%4x", | |
| devices[i]->deviceinfo.pci->vendor_id, | |
| devices[i]->deviceinfo.pci->device_id); | |
| } | |
| log_(_LOADER_WARNING, " %s", devices[i]->nodes[DRM_NODE_RENDER]); | |
| if (loader_drm_devices_match(devices[i], default_dev)) { | |
| log_(_LOADER_WARNING, " [default]"); | |
| } | |
| log_(_LOADER_WARNING, "\n"); | |
| } | |
| } | |
| if (prime.semantics == PRIME_IS_INTEGER && | |
| prime.v.as_integer >= num_devices) { | |
| printf("Inconsistent value (%d) for DRI_PRIME. Should be < %d " | |
| "(GPU devices count). Using: %d\n", | |
| prime.v.as_integer, num_devices, num_devices - 1); | |
| prime.v.as_integer = num_devices - 1; | |
| } | |
| for (i = 0; i < num_devices; i++) { | |
| if (!(devices[i]->available_nodes & 1 << DRM_NODE_RENDER)) | |
| continue; | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, "DRI_PRIME: device %d ", i); | |
| /* three formats of DRI_PRIME are supported: | |
| * "N": a >= 1 integer value. Select the Nth GPU, skipping the | |
| * default one. | |
| * id_path_tag: (for example "pci-0000_02_00_0") choose the card | |
| * with this id_path_tag. | |
| * vendor_id:device_id | |
| */ | |
| switch (prime.semantics) { | |
| case PRIME_IS_INTEGER: { | |
| /* Skip the default device */ | |
| if (loader_drm_devices_match(devices[i], default_dev)) { | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "skipped (default device)\n"); | |
| continue; | |
| } | |
| prime.v.as_integer--; | |
| /* Skip more GPUs? */ | |
| if (prime.v.as_integer) { | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "skipped (%d more to skip)\n", prime.v.as_integer - 1); | |
| continue; | |
| } | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, " -> "); | |
| break; | |
| } | |
| case PRIME_IS_VID_DID: { | |
| if (devices[i]->bustype == DRM_BUS_PCI && | |
| devices[i]->deviceinfo.pci->vendor_id == prime.v.as_vendor_device_ids.v && | |
| devices[i]->deviceinfo.pci->device_id == prime.v.as_vendor_device_ids.d) { | |
| /* Update prime for the "different_device" | |
| * determination below. */ | |
| free(prime.str); | |
| prime.str = drm_construct_id_path_tag(devices[i]); | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| " - vid:did match -> "); | |
| break; | |
| } else { | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "skipped (vid:did didn't match)\n"); | |
| } | |
| continue; | |
| } | |
| case PRIME_IS_PCI_TAG: { | |
| if (!drm_device_matches_tag(devices[i], prime.str)) { | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "skipped (pci id tag didn't match)\n"); | |
| continue; | |
| } | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, " - pci tag match -> "); | |
| break; | |
| } | |
| } | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "selected (%s)\n", devices[i]->nodes[DRM_NODE_RENDER]); | |
| drmFreeDevice(preferred_dev); | |
| *preferred_dev = devices[i]; | |
| devices[i] = NULL; | |
| break; | |
| } | |
| drmFreeDevices(devices, num_devices); | |
| if (i == num_devices) | |
| goto err; | |
| free(prime.str); | |
| return !loader_drm_devices_match(default_dev, *preferred_dev); | |
| err: | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "DRI_PRIME: error. Using the default GPU\n"); | |
| free(prime.str); | |
| no_prime_gpu_offloading: | |
| return false; | |
| } | |
| bool loader_get_user_preferred_fd(int *fd_render_gpu, int *original_fd) | |
| { | |
| int fd = -1; | |
| bool is_render_and_display_gpu_diff; | |
| drmDevicePtr render_dev, preferred_dev; | |
| bool debug = debug_get_bool_option("DRI_PRIME_DEBUG", false); | |
| if (drmGetDevice2(*fd_render_gpu, 0, &render_dev) != 0) | |
| return false; | |
| if (drmGetDevice2(*fd_render_gpu, 0, &preferred_dev) != 0) { | |
| drmFreeDevice(&render_dev); | |
| return false; | |
| }; | |
| is_render_and_display_gpu_diff = loader_get_user_preferred_device( | |
| render_dev, &preferred_dev); | |
| fd = loader_open_device(preferred_dev->nodes[DRM_NODE_RENDER]); | |
| if (fd < 0) { | |
| log_(debug ? _LOADER_WARNING : _LOADER_INFO, | |
| "DRI_PRIME: failed to open '%s'\n", | |
| render_dev->nodes[DRM_NODE_RENDER]); | |
| drmFreeDevice(&render_dev); | |
| drmFreeDevice(&preferred_dev); | |
| return false; | |
| } | |
| if (original_fd) { | |
| if (is_render_and_display_gpu_diff) { | |
| *original_fd = *fd_render_gpu; | |
| *fd_render_gpu = fd; | |
| } else { | |
| *original_fd = *fd_render_gpu; | |
| close(fd); | |
| } | |
| } else { | |
| close(*fd_render_gpu); | |
| *fd_render_gpu = fd; | |
| } | |
| drmFreeDevice(&render_dev); | |
| drmFreeDevice(&preferred_dev); | |
| return is_render_and_display_gpu_diff; | |
| } | |
| static bool | |
| drm_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) | |
| { | |
| drmDevicePtr device; | |
| if (drmGetDevice2(fd, 0, &device) != 0) { | |
| log_(_LOADER_WARNING, "MESA-LOADER: failed to retrieve device information\n"); | |
| return false; | |
| } | |
| if (device->bustype != DRM_BUS_PCI) { | |
| drmFreeDevice(&device); | |
| log_(_LOADER_DEBUG, "MESA-LOADER: device is not located on the PCI bus\n"); | |
| return false; | |
| } | |
| *vendor_id = device->deviceinfo.pci->vendor_id; | |
| *chip_id = device->deviceinfo.pci->device_id; | |
| drmFreeDevice(&device); | |
| return true; | |
| } | |
| #ifdef __linux__ | |
| static int loader_get_linux_pci_field(int maj, int min, const char *field) | |
| { | |
| char path[PATH_MAX + 1]; | |
| snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device/%s", maj, min, field); | |
| char *field_str = os_read_file(path, NULL); | |
| if (!field_str) { | |
| /* Probably non-PCI device. */ | |
| return 0; | |
| } | |
| int value = (int)strtoll(field_str, NULL, 16); | |
| free(field_str); | |
| return value; | |
| } | |
| static bool | |
| loader_get_linux_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) | |
| { | |
| struct stat sbuf; | |
| if (fstat(fd, &sbuf) != 0) { | |
| log_(_LOADER_DEBUG, "MESA-LOADER: failed to fstat fd\n"); | |
| return false; | |
| } | |
| int maj = major(sbuf.st_rdev); | |
| int min = minor(sbuf.st_rdev); | |
| *vendor_id = loader_get_linux_pci_field(maj, min, "vendor"); | |
| *chip_id = loader_get_linux_pci_field(maj, min, "device"); | |
| return *vendor_id && *chip_id; | |
| } | |
| #endif /* __linux__ */ | |
| bool | |
| loader_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) | |
| { | |
| #ifdef __linux__ | |
| /* Implementation without causing full enumeration of DRM devices. */ | |
| if (loader_get_linux_pci_id_for_fd(fd, vendor_id, chip_id)) | |
| return true; | |
| #endif | |
| return drm_get_pci_id_for_fd(fd, vendor_id, chip_id); | |
| } | |
| char * | |
| loader_get_device_name_for_fd(int fd) | |
| { | |
| return drmGetDeviceNameFromFd2(fd); | |
| } | |
| static char * | |
| loader_get_pci_driver(int fd) | |
| { | |
| int vendor_id, chip_id, i, j; | |
| char *driver = NULL; | |
| if (!loader_get_pci_id_for_fd(fd, &vendor_id, &chip_id)) | |
| return NULL; | |
| for (i = 0; i < ARRAY_SIZE(driver_map); i++) { | |
| if (vendor_id != driver_map[i].vendor_id) | |
| continue; | |
| if (driver_map[i].predicate && !driver_map[i].predicate(fd, driver_map[i].driver)) | |
| continue; | |
| if (driver_map[i].num_chips_ids == -1) { | |
| driver = strdup(driver_map[i].driver); | |
| goto out; | |
| } | |
| for (j = 0; j < driver_map[i].num_chips_ids; j++) | |
| if (driver_map[i].chip_ids[j] == chip_id) { | |
| driver = strdup(driver_map[i].driver); | |
| goto out; | |
| } | |
| } | |
| out: | |
| log_(driver ? _LOADER_DEBUG : _LOADER_WARNING, | |
| "pci id for fd %d: %04x:%04x, driver %s\n", | |
| fd, vendor_id, chip_id, driver); | |
| return driver; | |
| } | |
| char * | |
| loader_get_driver_for_fd(int fd) | |
| { | |
| char *driver; | |
| /* Allow an environment variable to force choosing a different driver | |
| * binary. If that driver binary can't survive on this FD, that's the | |
| * user's problem, but this allows vc4 simulator to run on an i965 host, | |
| * and may be useful for some touch testing of i915 on an i965 host. | |
| */ | |
| if (__normal_user()) { | |
| const char *override = os_get_option("MESA_LOADER_DRIVER_OVERRIDE"); | |
| if (override && strlen(override)) | |
| return strdup(override); | |
| } | |
| #if defined(USE_DRICONF) | |
| driver = loader_get_dri_config_driver(fd); | |
| if (driver) | |
| return driver; | |
| #endif | |
| driver = loader_get_pci_driver(fd); | |
| if (!driver) | |
| driver = loader_get_kernel_driver_name(fd); | |
| return driver; | |
| } | |
| void | |
| loader_set_logger(loader_logger *logger) | |
| { | |
| log_ = logger; | |
| } | |
| bool | |
| loader_bind_extensions(void *data, | |
| const struct dri_extension_match *matches, size_t num_matches, | |
| const __DRIextension **extensions) | |
| { | |
| bool ret = true; | |
| for (size_t j = 0; j < num_matches; j++) { | |
| const struct dri_extension_match *match = &matches[j]; | |
| const __DRIextension **field = (const __DRIextension **)((char *)data + matches[j].offset); | |
| for (size_t i = 0; extensions[i]; i++) { | |
| if (strcmp(extensions[i]->name, match->name) == 0 && | |
| extensions[i]->version >= match->version) { | |
| *field = extensions[i]; | |
| break; | |
| } | |
| } | |
| if (!*field) { | |
| log_(match->optional ? _LOADER_DEBUG : _LOADER_FATAL, "did not find extension %s version %d\n", | |
| match->name, match->version); | |
| if (!match->optional) | |
| ret = false; | |
| continue; | |
| } | |
| /* The loaders rely on the loaded DRI drivers being from the same Mesa | |
| * build so that we can reference the same structs on both sides. | |
| */ | |
| if (strcmp(match->name, __DRI_MESA) == 0) { | |
| const __DRImesaCoreExtension *mesa = (const __DRImesaCoreExtension *)*field; | |
| if (strcmp(mesa->version_string, MESA_INTERFACE_VERSION_STRING) != 0) { | |
| log_(_LOADER_FATAL, "libgallium not from this Mesa build (libgallium: '%s', loader: '%s')\n", | |
| mesa->version_string, MESA_INTERFACE_VERSION_STRING); | |
| ret = false; | |
| } | |
| } | |
| } | |
| return ret; | |
| } | |
| /** | |
| * Opens a driver or backend using its name, returning the library handle. | |
| * | |
| * \param driverName - a name like "i965", "radeon", "nouveau", etc. | |
| * \param lib_suffix - a suffix to append to the driver name to generate the | |
| * full library name. | |
| * \param search_path_vars - NULL-terminated list of env vars that can be used | |
| * \param default_search_path - a colon-separted list of directories used if | |
| * search_path_vars is NULL or none of the vars are set in the environment. | |
| * \param warn_on_fail - Log a warning if the driver is not found. | |
| */ | |
| void * | |
| loader_open_driver_lib(const char *driver_name, | |
| const char *lib_suffix, | |
| const char **search_path_vars, | |
| const char *default_search_path, | |
| bool warn_on_fail) | |
| { | |
| char path[PATH_MAX]; | |
| const char *search_paths, *next, *end; | |
| search_paths = NULL; | |
| if (__normal_user() && search_path_vars) { | |
| for (int i = 0; search_path_vars[i] != NULL; i++) { | |
| search_paths = os_get_option(search_path_vars[i]); | |
| if (search_paths) | |
| break; | |
| } | |
| } | |
| if (search_paths == NULL) | |
| search_paths = default_search_path; | |
| void *driver = NULL; | |
| const char *dl_error = NULL; | |
| end = search_paths + strlen(search_paths); | |
| for (const char *p = search_paths; p < end; p = next + 1) { | |
| int len; | |
| next = strchr(p, ':'); | |
| if (next == NULL) | |
| next = end; | |
| len = next - p; | |
| snprintf(path, sizeof(path), "%.*s/%s%s.so", len, | |
| p, driver_name, lib_suffix); | |
| driver = dlopen(path, RTLD_NOW | RTLD_LOCAL); | |
| if (driver == NULL) { | |
| dl_error = dlerror(); | |
| log_(_LOADER_DEBUG, "MESA-LOADER: failed to open %s: %s\n", | |
| path, dl_error); | |
| } | |
| /* not need continue to loop all paths once the driver is found */ | |
| if (driver != NULL) | |
| break; | |
| } | |
| if (driver == NULL) { | |
| if (warn_on_fail) { | |
| log_(_LOADER_WARNING, | |
| "MESA-LOADER: failed to open %s: %s (search paths %s, suffix %s)\n", | |
| driver_name, dl_error, search_paths, lib_suffix); | |
| } | |
| return NULL; | |
| } | |
| log_(_LOADER_DEBUG, "MESA-LOADER: dlopen(%s)\n", path); | |
| return driver; | |
| } |