X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Floader%2Floader.c;h=38395c8b768f1bbd35807b9bb9bcba68cc5ec313;hp=9ff5115221f3868af468195c53cc657a9066ed00;hb=HEAD;hpb=9153dd4b7eb95728aa9746a45a9dd136458d0213 diff --git a/src/loader/loader.c b/src/loader/loader.c index 9ff5115221f..38395c8b768 100644 --- a/src/loader/loader.c +++ b/src/loader/loader.c @@ -1,45 +1,7 @@ /* * Copyright (C) 2013 Rob Clark - * - * This code is derived from the following files. - * - * * src/glx/dri3_common.c - * Copyright © 2013 Keith Packard - * - * * src/egl/drivers/dri2/common.c - * * src/gbm/backends/dri/driver_name.c - * Copyright © 2011 Intel Corporation - * - * Authors: - * Kristian Høgsberg - * Benjamin Franzke - * - * * src/gallium/targets/egl-static/egl.c - * Copyright (C) 2010-2011 LunarG Inc. - * - * Authors: - * Chia-I Wu - * - * * src/gallium/state_trackers/egl/drm/native_drm.c - * Copyright (C) 2010 Chia-I Wu - * - * * src/egl/drivers/dri2/platform_android.c - * - * Copyright (C) 2010-2011 Chia-I Wu - * Copyright (C) 2010-2011 LunarG Inc. - * - * Based on platform_x11, which has - * - * Copyright © 2011 Intel Corporation - * - * * src/gallium/auxiliary/pipe-loader/pipe_loader_drm.c - * Copyright 2011 Intel Corporation - * Copyright 2012 Francisco Jerez - * All Rights Reserved. - * - * Authors: - * Kristian Høgsberg - * Benjamin Franzke + * Copyright (C) 2014-2016 Emil Velikov + * 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"), @@ -64,34 +26,47 @@ * Rob Clark */ +#include +#include +#include +#include #include #include +#include #include -#ifdef HAVE_LIBUDEV -#include -#include -#include #include #include -#include -#ifdef USE_DRICONF -#include "xmlconfig.h" -#include "xmlpool.h" +#include +#include +#ifdef MAJOR_IN_MKDEV +#include #endif +#ifdef MAJOR_IN_SYSMACROS +#include #endif -#ifdef HAVE_SYSFS -#include -#include -#endif +#include +#include #include "loader.h" -#ifndef __NOT_HAVE_DRM_H +#ifdef HAVE_LIBDRM #include +#define MAX_DRM_DEVICES 64 +#ifdef USE_DRICONF +#include "util/xmlconfig.h" +#include "util/driconf.h" +#endif #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) { @@ -102,614 +77,370 @@ static void default_logger(int level, const char *fmt, ...) } } -static void (*log_)(int level, const char *fmt, ...) = default_logger; - -#ifdef HAVE_LIBUDEV -#include +static loader_logger *log_ = default_logger; -static void *udev_handle = NULL; - -static void * -udev_dlopen_handle(void) +int +loader_open_device(const char *device_name) { - if (!udev_handle) { - udev_handle = dlopen("libudev.so.1", RTLD_LOCAL | RTLD_LAZY); - - if (!udev_handle) { - /* libudev.so.1 changed the return types of the two unref functions - * from voids to pointers. We don't use those return values, and the - * only ABI I've heard that cares about this kind of change (calling - * a function with a void * return that actually only returns void) - * might be ia64. - */ - udev_handle = dlopen("libudev.so.0", RTLD_LOCAL | RTLD_LAZY); - - if (!udev_handle) { - log_(_LOADER_WARNING, "Couldn't dlopen libudev.so.1 or " - "libudev.so.0, driver detection may be broken.\n"); - } - } + 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); } - - return udev_handle; -} - -static int dlsym_failed = 0; - -static void * -checked_dlsym(void *dlopen_handle, const char *name) -{ - void *result = dlsym(dlopen_handle, name); - if (!result) - dlsym_failed = 1; - return result; + if (fd == -1 && errno == EACCES) { + log_(_LOADER_WARNING, "failed to open %s: %s\n", + device_name, strerror(errno)); + } + return fd; } -#define UDEV_SYMBOL(ret, name, args) \ - ret (*name) args = checked_dlsym(udev_dlopen_handle(), #name); - - -static inline struct udev_device * -udev_device_new_from_fd(struct udev *udev, int fd) +static char *loader_get_kernel_driver_name(int fd) { - struct udev_device *device; - struct stat buf; - UDEV_SYMBOL(struct udev_device *, udev_device_new_from_devnum, - (struct udev *udev, char type, dev_t devnum)); +#if HAVE_LIBDRM + char *driver; + drmVersionPtr version = drmGetVersion(fd); - if (dlsym_failed) - return NULL; - - if (fstat(fd, &buf) < 0) { - log_(_LOADER_WARNING, "MESA-LOADER: failed to stat fd %d\n", fd); + if (!version) { + log_(_LOADER_WARNING, "failed to get driver name for fd %d\n", fd); return NULL; } - device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev); - if (device == NULL) { - log_(_LOADER_WARNING, - "MESA-LOADER: could not create udev device 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); - return device; + drmFreeVersion(version); + return driver; +#else + return NULL; +#endif } -static int -libudev_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) +bool +is_kernel_i915(int fd) { - struct udev *udev = NULL; - struct udev_device *device = NULL, *parent; - const char *pci_id; - UDEV_SYMBOL(struct udev *, udev_new, (void)); - UDEV_SYMBOL(struct udev_device *, udev_device_get_parent, - (struct udev_device *)); - UDEV_SYMBOL(const char *, udev_device_get_property_value, - (struct udev_device *, const char *)); - UDEV_SYMBOL(struct udev_device *, udev_device_unref, - (struct udev_device *)); - UDEV_SYMBOL(struct udev *, udev_unref, (struct udev *)); - - *chip_id = -1; - - if (dlsym_failed) - return 0; - - udev = udev_new(); - device = udev_device_new_from_fd(udev, fd); - if (!device) - goto out; - - parent = udev_device_get_parent(device); - if (parent == NULL) { - log_(_LOADER_WARNING, "MESA-LOADER: could not get parent device\n"); - goto out; - } + char *kernel_driver = loader_get_kernel_driver_name(fd); + bool is_i915 = kernel_driver && strcmp(kernel_driver, "i915") == 0; - pci_id = udev_device_get_property_value(parent, "PCI_ID"); - if (pci_id == NULL) { - log_(_LOADER_INFO, "MESA-LOADER: no PCI ID\n"); - *chip_id = -1; - goto out; - } else if (sscanf(pci_id, "%x:%x", vendor_id, chip_id) != 2) { - log_(_LOADER_WARNING, "MESA-LOADER: malformed PCI ID\n"); - *chip_id = -1; - goto out; - } - -out: - if (device) - udev_device_unref(device); - if (udev) - udev_unref(udev); - - return (*chip_id >= 0); + free(kernel_driver); + return is_i915; } -static char * -get_render_node_from_id_path_tag(struct udev *udev, - char *id_path_tag, - char another_tag) +#if defined(HAVE_LIBDRM) +int +loader_open_render_node(const char *name) { - struct udev_device *device; - struct udev_enumerate *e; - struct udev_list_entry *entry; - const char *path, *id_path_tag_tmp; - char *path_res; - char found = 0; - UDEV_SYMBOL(struct udev_enumerate *, udev_enumerate_new, - (struct udev *)); - UDEV_SYMBOL(int, udev_enumerate_add_match_subsystem, - (struct udev_enumerate *, const char *)); - UDEV_SYMBOL(int, udev_enumerate_add_match_sysname, - (struct udev_enumerate *, const char *)); - UDEV_SYMBOL(int, udev_enumerate_scan_devices, - (struct udev_enumerate *)); - UDEV_SYMBOL(struct udev_list_entry *, udev_enumerate_get_list_entry, - (struct udev_enumerate *)); - UDEV_SYMBOL(struct udev_list_entry *, udev_list_entry_get_next, - (struct udev_list_entry *)); - UDEV_SYMBOL(const char *, udev_list_entry_get_name, - (struct udev_list_entry *)); - UDEV_SYMBOL(struct udev_device *, udev_device_new_from_syspath, - (struct udev *, const char *)); - UDEV_SYMBOL(const char *, udev_device_get_property_value, - (struct udev_device *, const char *)); - UDEV_SYMBOL(const char *, udev_device_get_devnode, - (struct udev_device *)); - UDEV_SYMBOL(struct udev_device *, udev_device_unref, - (struct udev_device *)); - - e = udev_enumerate_new(udev); - udev_enumerate_add_match_subsystem(e, "drm"); - udev_enumerate_add_match_sysname(e, "render*"); - - udev_enumerate_scan_devices(e); - udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) { - path = udev_list_entry_get_name(entry); - device = udev_device_new_from_syspath(udev, path); - if (!device) - continue; - id_path_tag_tmp = udev_device_get_property_value(device, "ID_PATH_TAG"); - if (id_path_tag_tmp) { - if ((!another_tag && !strcmp(id_path_tag, id_path_tag_tmp)) || - (another_tag && strcmp(id_path_tag, id_path_tag_tmp))) { - found = 1; - break; - } - } - udev_device_unref(device); - } + drmDevicePtr devices[MAX_DRM_DEVICES], device; + int i, num_devices, fd = -1; - if (found) { - path_res = strdup(udev_device_get_devnode(device)); - udev_device_unref(device); - return path_res; - } - return NULL; -} + num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES); + if (num_devices <= 0) + return -ENOENT; -static char * -get_id_path_tag_from_fd(struct udev *udev, int fd) -{ - struct udev_device *device; - const char *id_path_tag_tmp; - char *id_path_tag; - UDEV_SYMBOL(const char *, udev_device_get_property_value, - (struct udev_device *, const char *)); - UDEV_SYMBOL(struct udev_device *, udev_device_unref, - (struct udev_device *)); - - device = udev_device_new_from_fd(udev, fd); - if (!device) - return NULL; + for (i = 0; i < num_devices; i++) { + device = devices[i]; - id_path_tag_tmp = udev_device_get_property_value(device, "ID_PATH_TAG"); - if (!id_path_tag_tmp) - return NULL; + if ((device->available_nodes & (1 << DRM_NODE_RENDER)) && + (device->bustype == DRM_BUS_PLATFORM)) { + drmVersionPtr version; - id_path_tag = strdup(id_path_tag_tmp); + fd = loader_open_device(device->nodes[DRM_NODE_RENDER]); + if (fd < 0) + continue; - udev_device_unref(device); - return id_path_tag; -} + version = drmGetVersion(fd); + if (!version) { + close(fd); + continue; + } -static int -drm_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 (strcmp(version->name, name) != 0) { + drmFreeVersion(version); + close(fd); + continue; + } + + drmFreeVersion(version); + break; + } } + drmFreeDevices(devices, num_devices); + + if (i == num_devices) + return -ENOENT; + return fd; } #ifdef USE_DRICONF -const char __driConfigOptionsLoader[] = +static const char __driConfigOptionsLoader[] = DRI_CONF_BEGIN DRI_CONF_SECTION_INITIALIZATION DRI_CONF_DEVICE_ID_PATH_TAG() + DRI_CONF_DRI_DRIVER() DRI_CONF_SECTION_END DRI_CONF_END; -#endif -int loader_get_user_preferred_fd(int default_fd, int *different_device) +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); + driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, + "loader", kernel_driver, NULL, 0, NULL, 0); + 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) { - struct udev *udev; -#ifdef USE_DRICONF driOptionCache defaultInitOptions; driOptionCache userInitOptions; -#endif - const char *dri_prime = getenv("DRI_PRIME"); char *prime = NULL; - int is_different_device = 0, fd = default_fd; - char *default_device_id_path_tag; - char *device_name = NULL; - char another_tag = 0; - UDEV_SYMBOL(struct udev *, udev_new, (void)); - UDEV_SYMBOL(struct udev *, udev_unref, (struct udev *)); - if (dri_prime) - prime = strdup(dri_prime); -#ifdef USE_DRICONF - else { - driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader); - driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, "loader"); - if (driCheckOption(&userInitOptions, "device_id", DRI_STRING)) - prime = strdup(driQueryOptionstr(&userInitOptions, "device_id")); - driDestroyOptionCache(&userInitOptions); - driDestroyOptionInfo(&defaultInitOptions); - } -#endif + driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader); + driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, + "loader", NULL, NULL, 0, NULL, 0); + if (driCheckOption(&userInitOptions, "device_id", DRI_STRING)) + prime = strdup(driQueryOptionstr(&userInitOptions, "device_id")); + driDestroyOptionCache(&userInitOptions); + driDestroyOptionInfo(&defaultInitOptions); - if (prime == NULL) { - *different_device = 0; - return default_fd; - } + return prime; +} +#endif - udev = udev_new(); - if (!udev) - goto prime_clean; +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; - default_device_id_path_tag = get_id_path_tag_from_fd(udev, default_fd); - if (!default_device_id_path_tag) - goto udev_clean; + if (device->bustype == DRM_BUS_PLATFORM) + fullname = device->businfo.platform->fullname; + else + fullname = device->businfo.host1x->fullname; - is_different_device = 1; - /* two format are supported: - * "1": choose any other card than the card used by default. - * id_path_tag: (for example "pci-0000_02_00_0") choose the card - * with this id_path_tag. - */ - if (!strcmp(prime,"1")) { - free(prime); - prime = strdup(default_device_id_path_tag); - /* request a card with a different card than the default card */ - another_tag = 1; - } else if (!strcmp(default_device_id_path_tag, prime)) - /* we are to get a new fd (render-node) of the same device */ - is_different_device = 0; - - device_name = get_render_node_from_id_path_tag(udev, - prime, - another_tag); - if (device_name == NULL) { - is_different_device = 0; - goto default_device_clean; - } + name = strrchr(fullname, '/'); + if (!name) + name = strdup(fullname); + else + name = strdup(name + 1); - fd = drm_open_device(device_name); - if (fd >= 0) { - close(default_fd); - } else { - fd = default_fd; - is_different_device = 0; - } - free(device_name); + address = strchr(name, '@'); + if (address) { + *address++ = '\0'; - default_device_clean: - free(default_device_id_path_tag); - udev_clean: - udev_unref(udev); - prime_clean: - free(prime); + if (asprintf(&tag, "platform-%s_%s", address, name) < 0) + tag = NULL; + } else { + if (asprintf(&tag, "platform-%s", name) < 0) + tag = NULL; + } - *different_device = is_different_device; - return fd; -} -#else -int loader_get_user_preferred_fd(int default_fd, int *different_device) -{ - *different_device = 0; - return default_fd; + free(name); + } + return tag; } -#endif -#if defined(HAVE_SYSFS) -static int -dev_node_from_fd(int fd, unsigned int *maj, unsigned int *min) +static bool drm_device_matches_tag(drmDevicePtr device, const char *prime_tag) { - struct stat buf; + char *tag = drm_construct_id_path_tag(device); + int ret; - if (fstat(fd, &buf) < 0) { - log_(_LOADER_WARNING, "MESA-LOADER: failed to stat fd %d\n", fd); - return -1; - } - - if (!S_ISCHR(buf.st_mode)) { - log_(_LOADER_WARNING, "MESA-LOADER: fd %d not a character device\n", fd); - return -1; - } + if (tag == NULL) + return false; - *maj = major(buf.st_rdev); - *min = minor(buf.st_rdev); + ret = strcmp(tag, prime_tag); - return 0; + free(tag); + return ret == 0; } -static int -sysfs_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) +static char *drm_get_id_path_tag_for_fd(int fd) { - unsigned int maj, min; - FILE *f; - char buf[0x40]; + drmDevicePtr device; + char *tag; - if (dev_node_from_fd(fd, &maj, &min) < 0) { - *chip_id = -1; - return 0; - } + if (drmGetDevice2(fd, 0, &device) != 0) + return NULL; - snprintf(buf, sizeof(buf), "/sys/dev/char/%d:%d/device/vendor", maj, min); - if (!(f = fopen(buf, "r"))) { - *chip_id = -1; - return 0; - } - if (fscanf(f, "%x", vendor_id) != 1) { - *chip_id = -1; - fclose(f); - return 0; - } - fclose(f); - snprintf(buf, sizeof(buf), "/sys/dev/char/%d:%d/device/device", maj, min); - if (!(f = fopen(buf, "r"))) { - *chip_id = -1; - return 0; - } - if (fscanf(f, "%x", chip_id) != 1) { - *chip_id = -1; - fclose(f); - return 0; - } - fclose(f); - return 1; + tag = drm_construct_id_path_tag(device); + drmFreeDevice(&device); + return tag; } -#endif -#if !defined(__NOT_HAVE_DRM_H) -/* for i915 */ -#include -/* for radeon */ -#include - -static int -drm_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) +int loader_get_user_preferred_fd(int default_fd, bool *different_device) { - drmVersionPtr version; + const char *dri_prime = getenv("DRI_PRIME"); + char *default_tag, *prime = NULL; + drmDevicePtr devices[MAX_DRM_DEVICES]; + int i, num_devices, fd = -1; - *chip_id = -1; + if (dri_prime) + prime = strdup(dri_prime); +#ifdef USE_DRICONF + else + prime = loader_get_dri_config_device_id(); +#endif - version = drmGetVersion(fd); - if (!version) { - log_(_LOADER_WARNING, "MESA-LOADER: invalid drm fd\n"); - return 0; - } - if (!version->name) { - log_(_LOADER_WARNING, "MESA-LOADER: unable to determine the driver name\n"); - drmFreeVersion(version); - return 0; + if (prime == NULL) { + *different_device = false; + return default_fd; } - if (strcmp(version->name, "i915") == 0) { - struct drm_i915_getparam gp; - int ret; + default_tag = drm_get_id_path_tag_for_fd(default_fd); + if (default_tag == NULL) + goto err; - *vendor_id = 0x8086; + num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES); + if (num_devices <= 0) + goto err; - memset(&gp, 0, sizeof(gp)); - gp.param = I915_PARAM_CHIPSET_ID; - gp.value = chip_id; - ret = drmCommandWriteRead(fd, DRM_I915_GETPARAM, &gp, sizeof(gp)); - if (ret) { - log_(_LOADER_WARNING, "MESA-LOADER: failed to get param for i915\n"); - *chip_id = -1; - } - } - else if (strcmp(version->name, "radeon") == 0) { - struct drm_radeon_info info; - int ret; - - *vendor_id = 0x1002; - - memset(&info, 0, sizeof(info)); - info.request = RADEON_INFO_DEVICE_ID; - info.value = (unsigned long) chip_id; - ret = drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info)); - if (ret) { - log_(_LOADER_WARNING, "MESA-LOADER: failed to get info for radeon\n"); - *chip_id = -1; + for (i = 0; i < num_devices; i++) { + if (!(devices[i]->available_nodes & 1 << DRM_NODE_RENDER)) + continue; + + /* two formats of DRI_PRIME are supported: + * "1": choose any other card than the card used by default. + * id_path_tag: (for example "pci-0000_02_00_0") choose the card + * with this id_path_tag. + */ + if (!strcmp(prime,"1")) { + if (drm_device_matches_tag(devices[i], default_tag)) + continue; + } else { + if (!drm_device_matches_tag(devices[i], prime)) + continue; } + + fd = loader_open_device(devices[i]->nodes[DRM_NODE_RENDER]); + break; } - else if (strcmp(version->name, "nouveau") == 0) { - *vendor_id = 0x10de; - /* not used */ - *chip_id = 0; - } - else if (strcmp(version->name, "vmwgfx") == 0) { - *vendor_id = 0x15ad; - /* assume SVGA II */ - *chip_id = 0x0405; - } + drmFreeDevices(devices, num_devices); - drmFreeVersion(version); + if (i == num_devices) + goto err; - return (*chip_id >= 0); -} -#endif + if (fd < 0) + goto err; + + close(default_fd); + *different_device = !!strcmp(default_tag, prime); + free(default_tag); + free(prime); + return fd; + + err: + *different_device = false; + + free(default_tag); + free(prime); + return default_fd; +} +#else int -loader_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) +loader_open_render_node(const char *name) { -#if HAVE_LIBUDEV - if (libudev_get_pci_id_for_fd(fd, vendor_id, chip_id)) - return 1; -#endif -#if HAVE_SYSFS - if (sysfs_get_pci_id_for_fd(fd, vendor_id, chip_id)) - return 1; -#endif -#if !defined(__NOT_HAVE_DRM_H) - if (drm_get_pci_id_for_fd(fd, vendor_id, chip_id)) - return 1; -#endif - return 0; + return -1; } - -#ifdef HAVE_LIBUDEV -static char * -libudev_get_device_name_for_fd(int fd) +int loader_get_user_preferred_fd(int default_fd, bool *different_device) { - char *device_name = NULL; - struct udev *udev; - struct udev_device *device; - const char *const_device_name; - UDEV_SYMBOL(struct udev *, udev_new, (void)); - UDEV_SYMBOL(const char *, udev_device_get_devnode, - (struct udev_device *)); - UDEV_SYMBOL(struct udev_device *, udev_device_unref, - (struct udev_device *)); - UDEV_SYMBOL(struct udev *, udev_unref, (struct udev *)); - - if (dlsym_failed) - return NULL; - - udev = udev_new(); - device = udev_device_new_from_fd(udev, fd); - if (device == NULL) - return NULL; - - const_device_name = udev_device_get_devnode(device); - if (!const_device_name) - goto out; - device_name = strdup(const_device_name); - -out: - udev_device_unref(device); - udev_unref(udev); - return device_name; + *different_device = false; + return default_fd; } #endif +#if defined(HAVE_LIBDRM) -#if HAVE_SYSFS -static char * -sysfs_get_device_name_for_fd(int fd) +static bool +drm_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) { - char *device_name = NULL; - unsigned int maj, min; - FILE *f; - char buf[0x40]; - static const char match[9] = "\0DEVNAME="; - int expected = 1; - - if (dev_node_from_fd(fd, &maj, &min) < 0) - return NULL; - - snprintf(buf, sizeof(buf), "/sys/dev/char/%d:%d/uevent", maj, min); - if (!(f = fopen(buf, "r"))) - return NULL; + drmDevicePtr device; - while (expected < sizeof(match)) { - int c = getc(f); - - if (c == EOF) { - fclose(f); - return NULL; - } else if (c == match[expected] ) - expected++; - else - expected = 0; + if (drmGetDevice2(fd, 0, &device) != 0) { + log_(_LOADER_WARNING, "MESA-LOADER: failed to retrieve device information\n"); + return false; } - strcpy(buf, "/dev/"); - if (fgets(buf + 5, sizeof(buf) - 5, f)) - device_name = strdup(buf); + if (device->bustype != DRM_BUS_PCI) { + drmFreeDevice(&device); + log_(_LOADER_DEBUG, "MESA-LOADER: device is not located on the PCI bus\n"); + return false; + } - fclose(f); - return device_name; + *vendor_id = device->deviceinfo.pci->vendor_id; + *chip_id = device->deviceinfo.pci->device_id; + drmFreeDevice(&device); + return true; } #endif +bool +loader_get_pci_id_for_fd(int fd, int *vendor_id, int *chip_id) +{ +#if HAVE_LIBDRM + return drm_get_pci_id_for_fd(fd, vendor_id, chip_id); +#endif + return false; +} + char * loader_get_device_name_for_fd(int fd) { char *result = NULL; -#if HAVE_LIBUDEV - if ((result = libudev_get_device_name_for_fd(fd))) - return result; -#endif -#if HAVE_SYSFS - if ((result = sysfs_get_device_name_for_fd(fd))) - return result; +#if HAVE_LIBDRM + result = drmGetDeviceNameFromFd2(fd); #endif + return result; } -char * -loader_get_driver_for_fd(int fd, unsigned driver_types) +static char * +loader_get_pci_driver(int fd) { int vendor_id, chip_id, i, j; char *driver = NULL; - if (!driver_types) - driver_types = _LOADER_GALLIUM | _LOADER_DRI; - - if (!loader_get_pci_id_for_fd(fd, &vendor_id, &chip_id)) { - -#ifndef __NOT_HAVE_DRM_H - /* fallback to drmGetVersion(): */ - 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_(_LOADER_INFO, "using driver %s for %d\n", driver, fd); - - drmFreeVersion(version); -#endif - - return driver; - } + if (!loader_get_pci_id_for_fd(fd, &vendor_id, &chip_id)) + return NULL; - for (i = 0; driver_map[i].driver; i++) { + for (i = 0; i < ARRAY_SIZE(driver_map); i++) { if (vendor_id != driver_map[i].vendor_id) continue; - if (!(driver_types & driver_map[i].driver_types)) - continue; - if (driver_map[i].predicate && !driver_map[i].predicate(fd)) continue; @@ -732,8 +463,142 @@ out: 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 (geteuid() == getuid()) { + driver = getenv("MESA_LOADER_DRIVER_OVERRIDE"); + if (driver) + return strdup(driver); + } + +#if defined(HAVE_LIBDRM) && 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(void (*logger)(int level, const char *fmt, ...)) +loader_set_logger(loader_logger *logger) { log_ = logger; } + +char * +loader_get_extensions_name(const char *driver_name) +{ + char *name = NULL; + + if (asprintf(&name, "%s_%s", __DRI_DRIVER_GET_EXTENSIONS, driver_name) < 0) + return NULL; + + const size_t len = strlen(name); + for (size_t i = 0; i < len; i++) { + if (name[i] == '-') + name[i] = '_'; + } + + return name; +} + +/** + * Opens a DRI driver using its driver name, returning the __DRIextension + * entrypoints. + * + * \param driverName - a name like "i965", "radeon", "nouveau", etc. + * \param out_driver - Address where the dlopen() return value will be stored. + * \param search_path_vars - NULL-terminated list of env vars that can be used + * to override the DEFAULT_DRIVER_DIR search path. + */ +const struct __DRIextensionRec ** +loader_open_driver(const char *driver_name, + void **out_driver_handle, + const char **search_path_vars) +{ + char path[PATH_MAX], *search_paths, *next, *end; + char *get_extensions_name; + const struct __DRIextensionRec **extensions = NULL; + const struct __DRIextensionRec **(*get_extensions)(void); + + search_paths = NULL; + if (geteuid() == getuid() && search_path_vars) { + for (int i = 0; search_path_vars[i] != NULL; i++) { + search_paths = getenv(search_path_vars[i]); + if (search_paths) + break; + } + } + if (search_paths == NULL) + search_paths = DEFAULT_DRIVER_DIR; + + void *driver = NULL; + end = search_paths + strlen(search_paths); + for (char *p = search_paths; p < end; p = next + 1) { + int len; + next = strchr(p, ':'); + if (next == NULL) + next = end; + + len = next - p; +#if USE_ELF_TLS + snprintf(path, sizeof(path), "%.*s/tls/%s_dri.so", len, p, driver_name); + driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); +#endif + if (driver == NULL) { + snprintf(path, sizeof(path), "%.*s/%s_dri.so", len, p, driver_name); + driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL); + if (driver == NULL) + log_(_LOADER_DEBUG, "MESA-LOADER: failed to open %s: %s\n", + path, dlerror()); + } + /* not need continue to loop all paths once the driver is found */ + if (driver != NULL) + break; + } + + if (driver == NULL) { + log_(_LOADER_WARNING, "MESA-LOADER: failed to open %s (search paths %s)\n", + driver_name, search_paths); + *out_driver_handle = NULL; + return NULL; + } + + log_(_LOADER_DEBUG, "MESA-LOADER: dlopen(%s)\n", path); + + get_extensions_name = loader_get_extensions_name(driver_name); + if (get_extensions_name) { + get_extensions = dlsym(driver, get_extensions_name); + if (get_extensions) { + extensions = get_extensions(); + } else { + log_(_LOADER_DEBUG, "MESA-LOADER: driver does not expose %s(): %s\n", + get_extensions_name, dlerror()); + } + free(get_extensions_name); + } + + if (!extensions) + extensions = dlsym(driver, __DRI_DRIVER_EXTENSIONS); + if (extensions == NULL) { + log_(_LOADER_WARNING, + "MESA-LOADER: driver exports no extensions (%s)\n", dlerror()); + dlclose(driver); + } + + *out_driver_handle = driver; + return extensions; +}