init

src/vulkan/device-select-layer/.clang-format

@@ -0,0 +1,4 @@
+BasedOnStyle: InheritParentConfig
+DisableFormat: false
+
+ColumnLimit: 100

src/vulkan/device-select-layer/VkLayer_MESA_device_select.json.in

@@ -0,0 +1,23 @@
+{
+  "file_format_version" : "1.0.0",
+  "layer" : {
+    "name": "VK_LAYER_MESA_device_select",
+    "type": "GLOBAL",
+    "library_path": "@library_path@",
+    "api_version": "1.4.303",
+    "implementation_version": "1",
+    "description": "Linux device selection layer",
+    "instance_extensions": [
+           {
+               "name": "VK_EXT_layer_settings",
+               "spec_version": "2"
+           }
+    ],
+    "functions": {
+      "vkNegotiateLoaderLayerInterfaceVersion": "vkNegotiateLoaderLayerInterfaceVersion"
+    },
+    "disable_environment": {
+      "NODEVICE_SELECT": "1"
+    }
+  }
+}

src/vulkan/device-select-layer/device_select.c

@@ -0,0 +1,416 @@
+/*
+ * Copyright © 2017 Google
+ * Copyright © 2019 Red Hat
+ *
+ * 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.
+ */
+
+/* Rules for device selection.
+ * Is there an X or wayland connection open (or DISPLAY set).
+ * If no - try and find which device was the boot_vga device.
+ * If yes - try and work out which device is the connection primary,
+ * DRI_PRIME tagged overrides only work if bus info, =1 will just pick an alternate.
+ */
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "util/macros.h"
+#include "device_select.h"
+
+static bool
+fill_drm_device_info(const struct instance_info *info, struct device_pci_info *drm_device,
+                     VkPhysicalDevice device)
+{
+   VkPhysicalDevicePCIBusInfoPropertiesEXT ext_pci_properties =
+      (VkPhysicalDevicePCIBusInfoPropertiesEXT){
+         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT};
+
+   VkPhysicalDeviceProperties2 properties =
+      (VkPhysicalDeviceProperties2){.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2};
+
+   if (info->has_vulkan11 && info->has_pci_bus)
+      properties.pNext = &ext_pci_properties;
+   device_select_get_properties(info, device, &properties);
+
+   drm_device->device_type = properties.properties.deviceType;
+   drm_device->dev_info.vendor_id = properties.properties.vendorID;
+   drm_device->dev_info.device_id = properties.properties.deviceID;
+   if (info->has_vulkan11 && info->has_pci_bus) {
+      drm_device->has_bus_info = true;
+      drm_device->bus_info.domain = ext_pci_properties.pciDomain;
+      drm_device->bus_info.bus = ext_pci_properties.pciBus;
+      drm_device->bus_info.dev = ext_pci_properties.pciDevice;
+      drm_device->bus_info.func = ext_pci_properties.pciFunction;
+   }
+   return drm_device->device_type == VK_PHYSICAL_DEVICE_TYPE_CPU;
+}
+
+static int
+device_select_find_explicit_default(struct device_pci_info *pci_infos, uint32_t device_count,
+                                    const char *selection)
+{
+   int default_idx = -1;
+   unsigned vendor_id, device_id;
+   int matched = sscanf(selection, "%x:%x", &vendor_id, &device_id);
+   if (matched != 2)
+      return default_idx;
+
+   for (unsigned i = 0; i < device_count; ++i) {
+      if (pci_infos[i].dev_info.vendor_id == vendor_id &&
+          pci_infos[i].dev_info.device_id == device_id)
+         default_idx = i;
+   }
+   return default_idx;
+}
+
+static int
+device_select_find_typed_default(struct device_pci_info *pci_infos, uint32_t device_count,
+                                 const char *selection)
+{
+   static struct {
+      const char *name;
+      VkPhysicalDeviceType type;
+   } names[] = {
+      {"other", VK_PHYSICAL_DEVICE_TYPE_OTHER},
+      {"integrated", VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU},
+      {"igpu", VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU},
+      {"discrete", VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU},
+      {"dgpu", VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU},
+      {"virtual", VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU},
+      {"vgpu", VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU},
+      {"cpu", VK_PHYSICAL_DEVICE_TYPE_CPU},
+   };
+
+   for (unsigned i = 0; i < ARRAY_SIZE(names); ++i) {
+      if (strncasecmp(names[i].name, selection, strlen(names[i].name)) == 0) {
+         for (unsigned j = 0; j < device_count; ++j) {
+            if (pci_infos[j].device_type == names[i].type)
+               return j;
+         }
+      }
+   }
+
+   return -1;
+}
+
+static int
+device_select_find_dri_prime_tag_default(struct device_pci_info *pci_infos, uint32_t device_count,
+                                         const char *dri_prime)
+{
+   int default_idx = -1;
+
+   /* Drop the trailing '!' if present. */
+   int ref = strlen("pci-xxxx_yy_zz_w");
+   int n = strlen(dri_prime);
+   if (n < ref)
+      return default_idx;
+   if (n == ref + 1 && dri_prime[n - 1] == '!')
+      n--;
+
+   for (unsigned i = 0; i < device_count; ++i) {
+      char *tag = NULL;
+      if (asprintf(&tag, "pci-%04x_%02x_%02x_%1u", pci_infos[i].bus_info.domain,
+                   pci_infos[i].bus_info.bus, pci_infos[i].bus_info.dev,
+                   pci_infos[i].bus_info.func) >= 0) {
+         if (strncmp(dri_prime, tag, n) == 0)
+            default_idx = i;
+      }
+      free(tag);
+   }
+   return default_idx;
+}
+
+static int
+device_select_find_boot_vga_vid_did(struct device_pci_info *pci_infos, uint32_t device_count)
+{
+   char path[1024];
+   int fd;
+   int default_idx = -1;
+   uint8_t boot_vga = 0;
+   ssize_t size_ret;
+#pragma pack(push, 1)
+   struct id {
+      uint16_t vid;
+      uint16_t did;
+   } id;
+#pragma pack(pop)
+
+   for (unsigned i = 0; i < 64; i++) {
+      snprintf(path, 1023, "/sys/class/drm/card%d/device/boot_vga", i);
+      fd = open(path, O_RDONLY);
+      if (fd != -1) {
+         uint8_t val;
+         size_ret = read(fd, &val, 1);
+         close(fd);
+         if (size_ret == 1 && val == '1')
+            boot_vga = 1;
+      } else {
+         return default_idx;
+      }
+
+      if (boot_vga) {
+         snprintf(path, 1023, "/sys/class/drm/card%d/device/config", i);
+         fd = open(path, O_RDONLY);
+         if (fd != -1) {
+            size_ret = read(fd, &id, 4);
+            close(fd);
+            if (size_ret != 4)
+               return default_idx;
+         } else {
+            return default_idx;
+         }
+         break;
+      }
+   }
+
+   if (!boot_vga)
+      return default_idx;
+
+   for (unsigned i = 0; i < device_count; ++i) {
+      if (id.vid == pci_infos[i].dev_info.vendor_id && id.did == pci_infos[i].dev_info.device_id) {
+         default_idx = i;
+         break;
+      }
+   }
+
+   return default_idx;
+}
+
+static int
+device_select_find_boot_vga_default(struct device_pci_info *pci_infos, uint32_t device_count)
+{
+   char boot_vga_path[1024];
+   int default_idx = -1;
+   for (unsigned i = 0; i < device_count; ++i) {
+      /* fallback to probing the pci bus boot_vga device. */
+      snprintf(boot_vga_path, 1023, "/sys/bus/pci/devices/%04x:%02x:%02x.%x/boot_vga",
+               pci_infos[i].bus_info.domain, pci_infos[i].bus_info.bus, pci_infos[i].bus_info.dev,
+               pci_infos[i].bus_info.func);
+      int fd = open(boot_vga_path, O_RDONLY);
+      if (fd != -1) {
+         uint8_t val;
+         if (read(fd, &val, 1) == 1) {
+            if (val == '1')
+               default_idx = i;
+         }
+         close(fd);
+      }
+      if (default_idx != -1)
+         break;
+   }
+   return default_idx;
+}
+
+static int
+device_select_find_non_cpu(struct device_pci_info *pci_infos, uint32_t device_count)
+{
+   int default_idx = -1;
+
+   /* pick first GPU device */
+   for (unsigned i = 0; i < device_count; ++i) {
+      if (pci_infos[i].device_type != VK_PHYSICAL_DEVICE_TYPE_CPU) {
+         default_idx = i;
+         break;
+      }
+   }
+   return default_idx;
+}
+
+static int
+find_non_cpu_skip(struct device_pci_info *pci_infos, uint32_t device_count, int skip_idx,
+                  int skip_count)
+{
+   for (unsigned i = 0; i < device_count; ++i) {
+      if (i == skip_idx)
+         continue;
+      if (pci_infos[i].device_type == VK_PHYSICAL_DEVICE_TYPE_CPU)
+         continue;
+      skip_count--;
+      if (skip_count > 0)
+         continue;
+
+      return i;
+   }
+   return -1;
+}
+
+static bool
+ends_with_exclamation_mark(const char *str)
+{
+   size_t n = strlen(str);
+   return n > 1 && str[n - 1] == '!';
+}
+
+static int
+get_selected(const struct instance_info *info, uint32_t count, struct device_pci_info *pci_infos,
+             const char *dri_prime, bool *expose_only_one_dev)
+{
+   int default_idx = -1;
+
+   if (info->selection)
+      default_idx = device_select_find_typed_default(pci_infos, count, info->selection);
+   if (default_idx != -1) {
+      if (info->debug)
+         fprintf(stderr,
+                 "device-select: device_select_find_typed_default for MESA_VK_DEVICE_SELECT "
+                 "selected %i\n",
+                 default_idx);
+      *expose_only_one_dev = ends_with_exclamation_mark(info->selection);
+      return default_idx;
+   }
+
+   if (info->selection)
+      default_idx = device_select_find_explicit_default(pci_infos, count, info->selection);
+   if (default_idx != -1) {
+      if (info->debug)
+         fprintf(stderr,
+                 "device-select: device_select_find_explicit_default for MESA_VK_DEVICE_SELECT "
+                 "selected %i\n",
+                 default_idx);
+      *expose_only_one_dev = ends_with_exclamation_mark(info->selection);
+      return default_idx;
+   }
+
+   if (!dri_prime)
+      return default_idx;
+
+   /* Try DRI_PRIME=vendor_id:device_id */
+   default_idx = device_select_find_explicit_default(pci_infos, count, dri_prime);
+   if (default_idx != -1) {
+      if (info->debug)
+         fprintf(stderr, "device-select: device_select_find_explicit_default selected %i\n",
+                 default_idx);
+      *expose_only_one_dev = ends_with_exclamation_mark(dri_prime);
+      return default_idx;
+   }
+
+   /* Try DRI_PRIME=pci-xxxx_yy_zz_w */
+   if (!info->has_vulkan11 && !info->has_pci_bus)
+      fprintf(stderr, "device-select: cannot correctly use DRI_PRIME tag\n");
+   else
+      default_idx = device_select_find_dri_prime_tag_default(pci_infos, count, dri_prime);
+
+   if (default_idx != -1) {
+      if (info->debug)
+         fprintf(stderr, "device-select: device_select_find_dri_prime_tag_default selected %i\n",
+                 default_idx);
+      *expose_only_one_dev = ends_with_exclamation_mark(dri_prime);
+   }
+
+   return default_idx;
+}
+
+static int
+get_default(const struct instance_info *info, uint32_t count, struct device_pci_info *pci_infos)
+{
+   int default_idx = -1;
+
+   bool has_cpu = false;
+   for (unsigned i = 0; i < count; ++i)
+      has_cpu |= pci_infos[i].device_type == VK_PHYSICAL_DEVICE_TYPE_CPU;
+
+   if (default_idx == -1 && info->has_wayland) {
+      default_idx = device_select_find_wayland_pci_default(pci_infos, count);
+      if (info->debug && default_idx != -1)
+         fprintf(stderr, "device-select: device_select_find_wayland_pci_default selected %i\n",
+                 default_idx);
+   }
+
+   if (default_idx == -1 && info->has_xcb) {
+      default_idx = device_select_find_xcb_pci_default(pci_infos, count);
+      if (info->debug && default_idx != -1)
+         fprintf(stderr, "device-select: device_select_find_xcb_pci_default selected %i\n",
+                 default_idx);
+   }
+
+   if (default_idx == -1) {
+      if (info->has_vulkan11 && info->has_pci_bus)
+         default_idx = device_select_find_boot_vga_default(pci_infos, count);
+      else
+         default_idx = device_select_find_boot_vga_vid_did(pci_infos, count);
+      if (info->debug && default_idx != -1)
+         fprintf(stderr, "device-select: device_select_find_boot_vga selected %i\n", default_idx);
+   }
+
+   /* If no GPU has been selected so far, select the first non-CPU device. If none are available,
+    * pick the first CPU device.
+    */
+   if (default_idx == -1) {
+      default_idx = device_select_find_non_cpu(pci_infos, count);
+      if (info->debug && default_idx != -1)
+         fprintf(stderr, "device-select: device_select_find_non_cpu selected %i\n", default_idx);
+   }
+
+   if (default_idx == -1 && has_cpu)
+      default_idx = 0;
+
+   return default_idx;
+}
+
+uint32_t
+device_select_get_first(const struct instance_info *info, uint32_t physical_device_count,
+                        VkPhysicalDevice *pPhysicalDevices, bool *expose_only_one_dev)
+{
+   int default_idx = -1;
+   int dri_prime_as_int = -1;
+   int cpu_count = 0;
+   if (info->dri_prime) {
+      if (strchr(info->dri_prime, ':') == NULL)
+         dri_prime_as_int = atoi(info->dri_prime);
+
+      if (dri_prime_as_int < 0)
+         dri_prime_as_int = 0;
+   }
+
+   struct device_pci_info *pci_infos =
+      (struct device_pci_info *)calloc(physical_device_count, sizeof(struct device_pci_info));
+   if (!pci_infos)
+      return 0;
+
+   for (unsigned i = 0; i < physical_device_count; ++i)
+      cpu_count += fill_drm_device_info(info, &pci_infos[i], pPhysicalDevices[i]) ? 1 : 0;
+
+   default_idx = get_selected(info, physical_device_count, pci_infos,
+                              dri_prime_as_int ? NULL : info->dri_prime, expose_only_one_dev);
+   if (default_idx == -1)
+      default_idx = get_default(info, physical_device_count, pci_infos);
+
+   /* DRI_PRIME=n handling - pick any other device than default. */
+   if (dri_prime_as_int > 0 && info->debug)
+      fprintf(stderr, "device-select: DRI_PRIME=%d, default_idx so far: %i\n", dri_prime_as_int,
+              default_idx);
+   if (dri_prime_as_int > 0 && (physical_device_count - cpu_count) > 1 &&
+       (default_idx == 0 || default_idx == 1)) {
+      default_idx =
+         find_non_cpu_skip(pci_infos, physical_device_count, default_idx, dri_prime_as_int);
+      if (default_idx != -1) {
+         if (info->debug)
+            fprintf(stderr, "device-select: find_non_cpu_skip selected %i\n", default_idx);
+         *expose_only_one_dev = ends_with_exclamation_mark(info->dri_prime);
+      }
+   }
+
+   free(pci_infos);
+   return default_idx == -1 ? 0 : default_idx;
+}

src/vulkan/device-select-layer/device_select.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright © 2019 Red Hat
+ *
+ * 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.
+ */
+#ifndef DEVICE_SELECT_H
+#define DEVICE_SELECT_H
+
+#include <vulkan/vulkan.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "xf86drm.h"
+
+struct instance_info {
+   PFN_vkDestroyInstance DestroyInstance;
+   PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+   PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups;
+   PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+   PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+   PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+   PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2;
+   bool has_pci_bus, has_vulkan11;
+   bool has_wayland, has_xcb;
+   bool xserver;
+
+   /* don't do device selection */
+   bool bypass_device_select;
+   bool debug;
+
+   char *selection;
+   char *dri_prime;
+   bool force_default_device;
+};
+
+/* We don't use `drmPciDeviceInfo` because it uses 16-bit ids,
+ * instead of Vulkan's 32-bit ones. */
+struct device_info {
+   uint32_t vendor_id;
+   uint32_t device_id;
+};
+
+struct device_pci_info {
+   struct device_info dev_info;
+   drmPciBusInfo bus_info;
+   bool has_bus_info;
+   VkPhysicalDeviceType device_type;
+};
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+int device_select_find_xcb_pci_default(struct device_pci_info *devices, uint32_t device_count);
+#else
+static inline int
+device_select_find_xcb_pci_default(struct device_pci_info *devices, uint32_t device_count)
+{
+   return -1;
+}
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+int device_select_find_wayland_pci_default(struct device_pci_info *devices, uint32_t device_count);
+#else
+static inline int
+device_select_find_wayland_pci_default(struct device_pci_info *devices, uint32_t device_count)
+{
+   return -1;
+}
+#endif
+
+void device_select_get_properties(const struct instance_info *info, VkPhysicalDevice device,
+                                  VkPhysicalDeviceProperties2 *properties);
+
+uint32_t device_select_get_first(const struct instance_info *info, uint32_t physical_device_count,
+                                 VkPhysicalDevice *pPhysicalDevices, bool *expose_only_one_dev);
+
+#endif

src/vulkan/device-select-layer/device_select_layer.c

@@ -0,0 +1,463 @@
+/*
+ * Copyright © 2017 Google
+ * Copyright © 2019 Red Hat
+ *
+ * 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.
+ */
+
+/* Rules for device selection.
+ * Is there an X or wayland connection open (or DISPLAY set).
+ * If no - try and find which device was the boot_vga device.
+ * If yes - try and work out which device is the connection primary,
+ * DRI_PRIME tagged overrides only work if bus info, =1 will just pick an alternate.
+ */
+
+#include <vulkan/vk_layer.h>
+#include <vulkan/vulkan.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "util/hash_table.h"
+#include "util/simple_mtx.h"
+#include "util/u_debug.h"
+#include "device_select.h"
+#include "vk_util.h"
+
+static struct hash_table *device_select_instance_ht = NULL;
+static simple_mtx_t device_select_mutex = SIMPLE_MTX_INITIALIZER;
+
+static void
+device_select_layer_add_instance(VkInstance instance, struct instance_info *info)
+{
+   simple_mtx_lock(&device_select_mutex);
+
+   if (!device_select_instance_ht)
+      device_select_instance_ht = _mesa_pointer_hash_table_create(NULL);
+   _mesa_hash_table_insert(device_select_instance_ht, instance, info);
+
+   simple_mtx_unlock(&device_select_mutex);
+}
+
+static struct instance_info *
+device_select_layer_get_instance(VkInstance instance)
+{
+   struct hash_entry *entry;
+   struct instance_info *info = NULL;
+   simple_mtx_lock(&device_select_mutex);
+   entry = _mesa_hash_table_search(device_select_instance_ht, (void *)instance);
+   if (entry)
+      info = (struct instance_info *)entry->data;
+   simple_mtx_unlock(&device_select_mutex);
+   return info;
+}
+
+static void
+device_select_layer_remove_instance(VkInstance instance)
+{
+   simple_mtx_lock(&device_select_mutex);
+
+   _mesa_hash_table_remove_key(device_select_instance_ht, instance);
+
+   if (_mesa_hash_table_num_entries(device_select_instance_ht) == 0) {
+      _mesa_hash_table_destroy(device_select_instance_ht, NULL);
+      device_select_instance_ht = NULL;
+   }
+
+   simple_mtx_unlock(&device_select_mutex);
+}
+
+static VkResult
+device_select_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                             const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
+{
+   VkLayerInstanceCreateInfo *chain_info = NULL;
+   bool bypass_device_select = false;
+   vk_foreach_struct_const(s, pCreateInfo->pNext) {
+      switch (s->sType) {
+      case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
+         const VkLayerInstanceCreateInfo *this_info = (const void *)s;
+         if (this_info->function == VK_LAYER_LINK_INFO)
+            chain_info = (VkLayerInstanceCreateInfo *)this_info; /* loses const */
+         break;
+      }
+      case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: {
+         const VkLayerSettingsCreateInfoEXT *lsci = (const void *)s;
+         for (unsigned i = 0; i < lsci->settingCount; i++) {
+            const VkLayerSettingEXT *ls = &lsci->pSettings[i];
+            if (!strcmp(ls->pLayerName, "MESA_device_select")) {
+               if (!strcmp(ls->pSettingName, "no_device_select")) {
+                  assert(ls->type == VK_LAYER_SETTING_TYPE_BOOL32_EXT);
+                  uint32_t *values = (uint32_t *)ls->pValues;
+                  bypass_device_select = values[0];
+               }
+            }
+         }
+         break;
+      }
+      default:
+         break;
+      }
+   }
+
+   assert(chain_info->u.pLayerInfo);
+
+   PFN_vkGetInstanceProcAddr GetInstanceProcAddr =
+      chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+   PFN_vkCreateInstance fpCreateInstance =
+      (PFN_vkCreateInstance)GetInstanceProcAddr(NULL, "vkCreateInstance");
+   if (fpCreateInstance == NULL) {
+      return VK_ERROR_INITIALIZATION_FAILED;
+   }
+
+   chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
+
+   const char *engineName =
+      pCreateInfo->pApplicationInfo && pCreateInfo->pApplicationInfo->pEngineName
+         ? pCreateInfo->pApplicationInfo->pEngineName
+         : "";
+   const char *applicationName =
+      pCreateInfo->pApplicationInfo && pCreateInfo->pApplicationInfo->pApplicationName
+         ? pCreateInfo->pApplicationInfo->pApplicationName
+         : "";
+   VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
+   if (result != VK_SUCCESS) {
+      return result;
+   }
+
+   bool zink = !strcmp(engineName, "mesa zink");
+   bool xwayland = !strcmp(applicationName, "Xwayland");
+   struct instance_info *info = (struct instance_info *)calloc(1, sizeof(struct instance_info));
+   info->GetInstanceProcAddr = GetInstanceProcAddr;
+   info->xserver = !strcmp(applicationName, "Xorg") || !strcmp(applicationName, "Xephyr");
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+   bool has_wayland = os_get_option("WAYLAND_DISPLAY") || os_get_option("WAYLAND_SOCKET");
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+   bool has_xcb = !!os_get_option("DISPLAY");
+#endif
+
+   for (unsigned i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+      if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) &&
+          has_wayland)
+         info->has_wayland = true;
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+      if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) &&
+          has_xcb)
+         info->has_xcb = !info->xserver || !zink;
+#endif
+   }
+
+   if (zink && xwayland)
+      bypass_device_select = true;
+   /*
+    * The loader is currently not able to handle GetPhysicalDeviceProperties2KHR calls in
+    * EnumeratePhysicalDevices when there are other layers present. To avoid mysterious crashes
+    * for users just use only the vulkan version for now.
+    */
+   info->bypass_device_select = bypass_device_select;
+   info->has_vulkan11 = pCreateInfo->pApplicationInfo &&
+                        pCreateInfo->pApplicationInfo->apiVersion >= VK_MAKE_VERSION(1, 1, 0);
+
+   info->debug = debug_get_bool_option("MESA_VK_DEVICE_SELECT_DEBUG", false) ||
+                 debug_get_bool_option("DRI_PRIME_DEBUG", false);
+   info->selection = os_get_option_dup("MESA_VK_DEVICE_SELECT");
+   info->dri_prime = os_get_option_dup("DRI_PRIME");
+   info->force_default_device =
+      debug_get_bool_option("MESA_VK_DEVICE_SELECT_FORCE_DEFAULT_DEVICE", false);
+
+#define DEVSEL_GET_CB(func)                                                                        \
+   info->func = (PFN_vk##func)info->GetInstanceProcAddr(*pInstance, "vk" #func)
+   DEVSEL_GET_CB(DestroyInstance);
+   DEVSEL_GET_CB(EnumeratePhysicalDevices);
+   DEVSEL_GET_CB(EnumeratePhysicalDeviceGroups);
+   DEVSEL_GET_CB(GetPhysicalDeviceProperties);
+   DEVSEL_GET_CB(EnumerateDeviceExtensionProperties);
+   if (info->has_vulkan11)
+      DEVSEL_GET_CB(GetPhysicalDeviceProperties2);
+#undef DEVSEL_GET_CB
+
+   device_select_layer_add_instance(*pInstance, info);
+
+   return VK_SUCCESS;
+}
+
+static void
+device_select_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
+{
+   struct instance_info *info = device_select_layer_get_instance(instance);
+
+   device_select_layer_remove_instance(instance);
+   info->DestroyInstance(instance, pAllocator);
+   free(info->dri_prime);
+   free(info->selection);
+   free(info);
+}
+
+void
+device_select_get_properties(const struct instance_info *info, VkPhysicalDevice device,
+                             VkPhysicalDeviceProperties2 *properties)
+{
+   if (info->GetPhysicalDeviceProperties2 && info->has_vulkan11)
+      info->GetPhysicalDeviceProperties2(device, properties);
+   else
+      info->GetPhysicalDeviceProperties(device, &properties->properties);
+}
+
+static void
+print_gpu(const struct instance_info *info, unsigned index, VkPhysicalDevice device)
+{
+   const char *type = "";
+   VkPhysicalDevicePCIBusInfoPropertiesEXT ext_pci_properties =
+      (VkPhysicalDevicePCIBusInfoPropertiesEXT){
+         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
+      };
+   VkPhysicalDeviceProperties2 properties = (VkPhysicalDeviceProperties2){
+      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+   };
+   if (info->has_vulkan11 && info->has_pci_bus)
+      properties.pNext = &ext_pci_properties;
+   device_select_get_properties(info, device, &properties);
+
+   switch (properties.properties.deviceType) {
+   case VK_PHYSICAL_DEVICE_TYPE_OTHER:
+   default:
+      type = "other";
+      break;
+   case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
+      type = "integrated GPU";
+      break;
+   case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
+      type = "discrete GPU";
+      break;
+   case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
+      type = "virtual GPU";
+      break;
+   case VK_PHYSICAL_DEVICE_TYPE_CPU:
+      type = "CPU";
+      break;
+   }
+   fprintf(stderr, "  GPU %d: %x:%x \"%s\" %s", index, properties.properties.vendorID,
+           properties.properties.deviceID, properties.properties.deviceName, type);
+   if (info->has_vulkan11 && info->has_pci_bus)
+      fprintf(stderr, " %04x:%02x:%02x.%x", ext_pci_properties.pciDomain, ext_pci_properties.pciBus,
+              ext_pci_properties.pciDevice, ext_pci_properties.pciFunction);
+   fprintf(stderr, "\n");
+}
+
+static VkResult
+device_select_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
+                                       VkPhysicalDevice *pPhysicalDevices)
+{
+   struct instance_info *info = device_select_layer_get_instance(instance);
+   uint32_t physical_device_count = 0;
+   uint32_t selected_physical_device_count = 0;
+   bool expose_only_one_dev = false;
+   if (info->bypass_device_select)
+      return info->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+   VkResult result = info->EnumeratePhysicalDevices(instance, &physical_device_count, NULL);
+   VK_OUTARRAY_MAKE_TYPED(VkPhysicalDevice, out, pPhysicalDevices, pPhysicalDeviceCount);
+   if (result != VK_SUCCESS)
+      return result;
+
+   VkPhysicalDevice *physical_devices =
+      (VkPhysicalDevice *)calloc(sizeof(VkPhysicalDevice), physical_device_count);
+   VkPhysicalDevice *selected_physical_devices =
+      (VkPhysicalDevice *)calloc(sizeof(VkPhysicalDevice), physical_device_count);
+
+   if (!physical_devices || !selected_physical_devices) {
+      result = VK_ERROR_OUT_OF_HOST_MEMORY;
+      goto out;
+   }
+
+   result = info->EnumeratePhysicalDevices(instance, &physical_device_count, physical_devices);
+   if (result != VK_SUCCESS)
+      goto out;
+
+   for (unsigned i = 0; i < physical_device_count; i++) {
+      uint32_t count;
+      info->EnumerateDeviceExtensionProperties(physical_devices[i], NULL, &count, NULL);
+      if (count > 0) {
+         VkExtensionProperties *extensions = calloc(count, sizeof(VkExtensionProperties));
+         if (info->EnumerateDeviceExtensionProperties(physical_devices[i], NULL, &count,
+                                                      extensions) == VK_SUCCESS) {
+            for (unsigned j = 0; j < count; j++) {
+               if (!strcmp(extensions[j].extensionName, VK_EXT_PCI_BUS_INFO_EXTENSION_NAME))
+                  info->has_pci_bus = true;
+            }
+         }
+         free(extensions);
+      }
+   }
+   if (info->debug || (info->selection && strcmp(info->selection, "list") == 0)) {
+      fprintf(stderr, "selectable devices:\n");
+      for (unsigned i = 0; i < physical_device_count; ++i)
+         print_gpu(info, i, physical_devices[i]);
+
+      if (info->selection && strcmp(info->selection, "list") == 0)
+         exit(0);
+   }
+
+   unsigned selected_index =
+      device_select_get_first(info, physical_device_count, physical_devices, &expose_only_one_dev);
+   selected_physical_device_count = physical_device_count;
+   selected_physical_devices[0] = physical_devices[selected_index];
+   for (unsigned i = 0; i < physical_device_count - 1; ++i) {
+      unsigned this_idx = i < selected_index ? i : i + 1;
+      selected_physical_devices[i + 1] = physical_devices[this_idx];
+   }
+
+   if (selected_physical_device_count == 0) {
+      fprintf(stderr, "WARNING: selected no devices with MESA_VK_DEVICE_SELECT\n");
+   }
+
+   assert(result == VK_SUCCESS);
+
+   /* do not give multiple device option to app if force default device */
+   if (info->force_default_device && selected_physical_device_count != 0)
+      expose_only_one_dev = true;
+
+   if (expose_only_one_dev)
+      selected_physical_device_count = 1;
+
+   for (unsigned i = 0; i < selected_physical_device_count; i++) {
+      vk_outarray_append_typed(VkPhysicalDevice, &out, ent)
+      {
+         *ent = selected_physical_devices[i];
+      }
+   }
+   result = vk_outarray_status(&out);
+out:
+   free(physical_devices);
+   free(selected_physical_devices);
+   return result;
+}
+
+static VkResult
+device_select_EnumeratePhysicalDeviceGroups(VkInstance instance,
+                                            uint32_t *pPhysicalDeviceGroupCount,
+                                            VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroups)
+{
+   struct instance_info *info = device_select_layer_get_instance(instance);
+   uint32_t physical_device_group_count = 0;
+   uint32_t selected_physical_device_group_count = 0;
+   if (info->bypass_device_select)
+      return info->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount,
+                                                 pPhysicalDeviceGroups);
+   VkResult result =
+      info->EnumeratePhysicalDeviceGroups(instance, &physical_device_group_count, NULL);
+   VK_OUTARRAY_MAKE_TYPED(VkPhysicalDeviceGroupProperties, out, pPhysicalDeviceGroups,
+                          pPhysicalDeviceGroupCount);
+
+   if (result != VK_SUCCESS)
+      return result;
+
+   VkPhysicalDeviceGroupProperties *physical_device_groups =
+      (VkPhysicalDeviceGroupProperties *)calloc(sizeof(VkPhysicalDeviceGroupProperties),
+                                                physical_device_group_count);
+   VkPhysicalDeviceGroupProperties *selected_physical_device_groups =
+      (VkPhysicalDeviceGroupProperties *)calloc(sizeof(VkPhysicalDeviceGroupProperties),
+                                                physical_device_group_count);
+
+   if (!physical_device_groups || !selected_physical_device_groups) {
+      result = VK_ERROR_OUT_OF_HOST_MEMORY;
+      goto out;
+   }
+
+   for (unsigned i = 0; i < physical_device_group_count; i++)
+      physical_device_groups[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
+
+   result = info->EnumeratePhysicalDeviceGroups(instance, &physical_device_group_count,
+                                                physical_device_groups);
+   if (result != VK_SUCCESS)
+      goto out;
+
+   /* just sort groups with CPU devices to the end? - assume nobody will mix these */
+   int num_gpu_groups = 0;
+   int num_cpu_groups = 0;
+   selected_physical_device_group_count = physical_device_group_count;
+   for (unsigned i = 0; i < physical_device_group_count; i++) {
+      bool group_has_cpu_device = false;
+      for (unsigned j = 0; j < physical_device_groups[i].physicalDeviceCount; j++) {
+         VkPhysicalDevice physical_device = physical_device_groups[i].physicalDevices[j];
+         VkPhysicalDeviceProperties2 properties = (VkPhysicalDeviceProperties2){
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+         };
+         info->GetPhysicalDeviceProperties(physical_device, &properties.properties);
+         group_has_cpu_device = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
+      }
+
+      if (group_has_cpu_device) {
+         selected_physical_device_groups[physical_device_group_count - num_cpu_groups - 1] =
+            physical_device_groups[i];
+         num_cpu_groups++;
+      } else {
+         selected_physical_device_groups[num_gpu_groups] = physical_device_groups[i];
+         num_gpu_groups++;
+      }
+   }
+
+   assert(result == VK_SUCCESS);
+
+   for (unsigned i = 0; i < selected_physical_device_group_count; i++) {
+      vk_outarray_append_typed(VkPhysicalDeviceGroupProperties, &out, ent)
+      {
+         *ent = selected_physical_device_groups[i];
+      }
+   }
+   result = vk_outarray_status(&out);
+out:
+   free(physical_device_groups);
+   free(selected_physical_device_groups);
+   return result;
+}
+
+static void (*get_instance_proc_addr(VkInstance instance, const char *name))()
+{
+   if (strcmp(name, "vkGetInstanceProcAddr") == 0)
+      return (void (*)())get_instance_proc_addr;
+   if (strcmp(name, "vkCreateInstance") == 0)
+      return (void (*)())device_select_CreateInstance;
+   if (strcmp(name, "vkDestroyInstance") == 0)
+      return (void (*)())device_select_DestroyInstance;
+   if (strcmp(name, "vkEnumeratePhysicalDevices") == 0)
+      return (void (*)())device_select_EnumeratePhysicalDevices;
+   if (strcmp(name, "vkEnumeratePhysicalDeviceGroups") == 0)
+      return (void (*)())device_select_EnumeratePhysicalDeviceGroups;
+
+   struct instance_info *info = device_select_layer_get_instance(instance);
+   return info->GetInstanceProcAddr(instance, name);
+}
+
+PUBLIC VkResult
+vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct)
+{
+   if (pVersionStruct->loaderLayerInterfaceVersion < 2)
+      return VK_ERROR_INITIALIZATION_FAILED;
+   pVersionStruct->loaderLayerInterfaceVersion = 2;
+
+   pVersionStruct->pfnGetInstanceProcAddr = get_instance_proc_addr;
+
+   return VK_SUCCESS;
+}

src/vulkan/device-select-layer/device_select_wayland.c

@@ -0,0 +1,273 @@
+/*
+ * Copyright © 2019 Red Hat
+ *
+ * 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.
+ */
+#include "util/macros.h"
+#include <wayland-client.h>
+#ifdef HAVE_BIND_WL_DISPLAY
+#include "wayland-drm-client-protocol.h"
+#endif
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <xf86drm.h>
+#include "device_select.h"
+#include "linux-dmabuf-unstable-v1-client-protocol.h"
+
+struct device_select_wayland_info {
+#ifdef HAVE_BIND_WL_DISPLAY
+   struct wl_drm *wl_drm;
+   drmDevicePtr drm_dev_info;
+#endif
+
+   struct zwp_linux_dmabuf_v1 *wl_dmabuf;
+   struct zwp_linux_dmabuf_feedback_v1 *wl_dmabuf_feedback;
+   struct wl_fixes *wl_fixes;
+   drmDevicePtr dmabuf_dev_info;
+};
+
+#ifdef HAVE_BIND_WL_DISPLAY
+static void
+device_select_drm_handle_device(void *data, struct wl_drm *drm, const char *device)
+{
+   struct device_select_wayland_info *info = data;
+
+   int fd = open(device, O_RDWR | O_CLOEXEC);
+   if (fd == -1)
+      return;
+
+   drmGetDevice2(fd, 0, &info->drm_dev_info);
+   close(fd);
+}
+
+static void
+device_select_drm_handle_format(void *data, struct wl_drm *drm, uint32_t format)
+{
+   /* ignore this event */
+}
+
+static void
+device_select_drm_handle_authenticated(void *data, struct wl_drm *drm)
+{
+   /* ignore this event */
+}
+
+static void
+device_select_drm_handle_capabilities(void *data, struct wl_drm *drm, uint32_t value)
+{
+   /* ignore this event */
+}
+
+static const struct wl_drm_listener ds_drm_listener = {
+   .device = device_select_drm_handle_device,
+   .format = device_select_drm_handle_format,
+   .authenticated = device_select_drm_handle_authenticated,
+   .capabilities = device_select_drm_handle_capabilities,
+};
+#endif
+
+static void
+default_dmabuf_feedback_format_table(
+   void *data, struct zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1, int32_t fd,
+   uint32_t size)
+{
+
+   /* ignore this event */
+   close(fd);
+}
+
+static void
+default_dmabuf_feedback_main_device(void *data,
+                                    struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                    struct wl_array *device)
+{
+
+   struct device_select_wayland_info *info = data;
+
+   dev_t dev_id;
+   assert(device->size == sizeof(dev_id));
+   memcpy(&dev_id, device->data, device->size);
+
+   drmGetDeviceFromDevId(dev_id, 0, &info->dmabuf_dev_info);
+   return;
+}
+
+static void
+default_dmabuf_feedback_tranche_target_device(void *data,
+                                              struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                              struct wl_array *device)
+{
+   /* ignore this event */
+}
+
+static void
+default_dmabuf_feedback_tranche_flags(void *data,
+                                      struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                      uint32_t flags)
+{
+   /* ignore this event */
+}
+
+static void
+default_dmabuf_feedback_tranche_formats(void *data,
+                                        struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                        struct wl_array *indices)
+{
+   /* ignore this event */
+}
+
+static void
+default_dmabuf_feedback_tranche_done(void *data,
+                                     struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback)
+{
+   /* ignore this event */
+}
+
+static void
+default_dmabuf_feedback_done(void *data, struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback)
+{
+   /* ignore this event */
+}
+
+static const struct zwp_linux_dmabuf_feedback_v1_listener dmabuf_feedback_listener = {
+   .format_table = default_dmabuf_feedback_format_table,
+   .main_device = default_dmabuf_feedback_main_device,
+   .tranche_target_device = default_dmabuf_feedback_tranche_target_device,
+   .tranche_flags = default_dmabuf_feedback_tranche_flags,
+   .tranche_formats = default_dmabuf_feedback_tranche_formats,
+   .tranche_done = default_dmabuf_feedback_tranche_done,
+   .done = default_dmabuf_feedback_done,
+};
+
+static void
+device_select_registry_global(void *data, struct wl_registry *registry, uint32_t name,
+                              const char *interface, uint32_t version)
+{
+   struct device_select_wayland_info *info = data;
+#if HAVE_BIND_WL_DISPLAY
+   if (strcmp(interface, wl_drm_interface.name) == 0) {
+      info->wl_drm = wl_registry_bind(registry, name, &wl_drm_interface, MIN2(version, 2));
+      wl_drm_add_listener(info->wl_drm, &ds_drm_listener, data);
+   } else
+#endif
+   if (strcmp(interface, zwp_linux_dmabuf_v1_interface.name) == 0 &&
+       version >= ZWP_LINUX_DMABUF_V1_GET_DEFAULT_FEEDBACK_SINCE_VERSION) {
+      info->wl_dmabuf = wl_registry_bind(registry, name, &zwp_linux_dmabuf_v1_interface,
+                                         ZWP_LINUX_DMABUF_V1_GET_DEFAULT_FEEDBACK_SINCE_VERSION);
+      info->wl_dmabuf_feedback = zwp_linux_dmabuf_v1_get_default_feedback(info->wl_dmabuf);
+      zwp_linux_dmabuf_feedback_v1_add_listener(info->wl_dmabuf_feedback, &dmabuf_feedback_listener,
+                                                data);
+#ifdef WL_FIXES_INTERFACE
+   } else if (strcmp(interface, wl_fixes_interface.name) == 0) {
+      info->wl_fixes = wl_registry_bind(registry, name, &wl_fixes_interface, 1);
+#endif
+   }
+}
+
+static void
+device_select_registry_global_remove_cb(void *data, struct wl_registry *registry, uint32_t name)
+{
+}
+
+int
+device_select_find_wayland_pci_default(struct device_pci_info *devices, uint32_t device_count)
+{
+   struct wl_display *display;
+   struct wl_registry *registry = NULL;
+   unsigned default_idx = -1;
+   struct device_select_wayland_info info = {};
+
+   display = wl_display_connect(NULL);
+   if (!display)
+      return -1;
+
+   registry = wl_display_get_registry(display);
+   if (!registry) {
+      wl_display_disconnect(display);
+      return -1;
+   }
+
+   static const struct wl_registry_listener registry_listener = {
+      device_select_registry_global, device_select_registry_global_remove_cb};
+
+   wl_registry_add_listener(registry, &registry_listener, &info);
+   wl_display_dispatch(display);
+   wl_display_roundtrip(display);
+
+   drmDevicePtr target = NULL;
+   if (info.dmabuf_dev_info != NULL) {
+      target = info.dmabuf_dev_info;
+   }
+#ifdef HAVE_BIND_WL_DISPLAY
+   if (target == NULL && info.drm_dev_info != NULL) {
+      target = info.drm_dev_info;
+   }
+#endif
+   if (target == NULL) {
+      goto done;
+   }
+
+   for (unsigned i = 0; i < device_count; i++) {
+      if (devices[i].has_bus_info) {
+         if (target->businfo.pci->domain == devices[i].bus_info.domain &&
+             target->businfo.pci->bus == devices[i].bus_info.bus &&
+             target->businfo.pci->dev == devices[i].bus_info.dev &&
+             target->businfo.pci->func == devices[i].bus_info.func) {
+            default_idx = i;
+            break;
+         }
+      } else {
+         if (target->deviceinfo.pci->vendor_id == devices[i].dev_info.vendor_id &&
+             target->deviceinfo.pci->device_id == devices[i].dev_info.device_id) {
+            default_idx = i;
+            break;
+         }
+      }
+   }
+
+done:
+   if (info.dmabuf_dev_info != NULL)
+      drmFreeDevice(&info.dmabuf_dev_info);
+#ifdef HAVE_BIND_WL_DISPLAY
+   if (info.drm_dev_info != NULL)
+      drmFreeDevice(&info.drm_dev_info);
+#endif
+
+   if (info.wl_dmabuf_feedback)
+      zwp_linux_dmabuf_feedback_v1_destroy(info.wl_dmabuf_feedback);
+   if (info.wl_dmabuf)
+      zwp_linux_dmabuf_v1_destroy(info.wl_dmabuf);
+#ifdef HAVE_BIND_WL_DISPLAY
+   if (info.wl_drm)
+      wl_drm_destroy(info.wl_drm);
+#endif
+#ifdef WL_FIXES_INTERFACE
+   if (info.wl_fixes) {
+      wl_fixes_destroy_registry(info.wl_fixes, registry);
+      wl_fixes_destroy(info.wl_fixes);
+   }
+#endif
+
+   wl_registry_destroy(registry);
+   wl_display_disconnect(display);
+   return default_idx;
+}

src/vulkan/device-select-layer/device_select_x11.c

@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2019 Red Hat
+ *
+ * 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.
+ */
+
+/* connect to an X server and work out the default device. */
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <xf86drm.h>
+#include <xcb/dri3.h>
+#include <xcb/xcb.h>
+
+#include "device_select.h"
+static int
+ds_dri3_open(xcb_connection_t *conn, xcb_window_t root, uint32_t provider)
+{
+   xcb_dri3_open_cookie_t cookie;
+   xcb_dri3_open_reply_t *reply;
+   int fd;
+
+   cookie = xcb_dri3_open(conn, root, provider);
+
+   reply = xcb_dri3_open_reply(conn, cookie, NULL);
+   if (!reply)
+      return -1;
+
+   if (reply->nfd != 1) {
+      free(reply);
+      return -1;
+   }
+
+   fd = xcb_dri3_open_reply_fds(conn, reply)[0];
+   free(reply);
+   fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
+
+   return fd;
+}
+
+int
+device_select_find_xcb_pci_default(struct device_pci_info *devices, uint32_t device_count)
+{
+   const xcb_setup_t *setup;
+   xcb_screen_iterator_t iter;
+   int scrn;
+   xcb_connection_t *conn;
+   int default_idx = -1;
+   drmDevicePtr xdev = NULL;
+
+   conn = xcb_connect(NULL, &scrn);
+   if (xcb_connection_has_error(conn)) {
+      xcb_disconnect(conn);
+      return -1;
+   }
+
+   xcb_query_extension_cookie_t dri3_cookie;
+   xcb_query_extension_reply_t *dri3_reply = NULL;
+
+   dri3_cookie = xcb_query_extension(conn, 4, "DRI3");
+   dri3_reply = xcb_query_extension_reply(conn, dri3_cookie, NULL);
+
+   if (!dri3_reply)
+      goto out;
+
+   if (dri3_reply->present == 0)
+      goto out;
+
+   setup = xcb_get_setup(conn);
+   iter = xcb_setup_roots_iterator(setup);
+
+   xcb_screen_t *screen = iter.data;
+
+   int dri3_fd = ds_dri3_open(conn, screen->root, 0);
+   if (dri3_fd == -1)
+      goto out;
+
+   int ret = drmGetDevice2(dri3_fd, 0, &xdev);
+   close(dri3_fd);
+   if (ret < 0)
+      goto out;
+
+   for (unsigned i = 0; i < device_count; i++) {
+      if (devices[i].has_bus_info) {
+         if (xdev->businfo.pci->domain == devices[i].bus_info.domain &&
+             xdev->businfo.pci->bus == devices[i].bus_info.bus &&
+             xdev->businfo.pci->dev == devices[i].bus_info.dev &&
+             xdev->businfo.pci->func == devices[i].bus_info.func) {
+            default_idx = i;
+         }
+      } else {
+         if (xdev->deviceinfo.pci->vendor_id == devices[i].dev_info.vendor_id &&
+             xdev->deviceinfo.pci->device_id == devices[i].dev_info.device_id)
+            default_idx = i;
+      }
+      if (default_idx != -1)
+         break;
+   }
+
+out:
+   free(dri3_reply);
+   drmFreeDevice(&xdev); /* Is NULL pointer safe. */
+   xcb_disconnect(conn);
+   return default_idx;
+}

src/vulkan/device-select-layer/meson.build

@@ -0,0 +1,55 @@
+# Copyright © 2019 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+vklayer_files = files(
+  'device_select.c',
+  'device_select_layer.c',
+)
+
+vklayer_deps = []
+vklayer_flags = []
+
+if with_platform_x11
+   vklayer_files += files('device_select_x11.c')
+   vklayer_deps += dep_xcb_dri3
+endif
+
+if with_platform_wayland
+   vklayer_files += files('device_select_wayland.c')
+   if with_wayland_bind_display
+     vklayer_files += [ wayland_drm_client_protocol_h, wayland_drm_protocol_c ]
+     vklayer_flags += [ '-DHAVE_BIND_WL_DISPLAY' ]
+   endif
+   vklayer_files += wp_files['linux-dmabuf-unstable-v1']
+   vklayer_deps += dep_wayland_client
+endif
+
+vklayer_mesa_device_select = shared_library(
+  'VkLayer_MESA_device_select',
+  vklayer_files,
+  c_args : [no_override_init_args, vklayer_flags],
+  gnu_symbol_visibility : 'hidden',
+  dependencies : [
+    idep_vulkan_util, idep_vulkan_wsi_headers, idep_mesautil, vklayer_deps,
+    dep_libdrm, dep_dl
+  ],
+  include_directories : [inc_include, inc_util, inc_src],
+  link_args : cc.get_supported_link_arguments(['-Wl,-Bsymbolic-functions', '-Wl,-z,relro']),
+  install : true
+)
+
+configure_file(
+  configuration : {'library_path' : 'libVkLayer_MESA_device_select.so'},
+  input : 'VkLayer_MESA_device_select.json.in',
+  output : '@BASENAME@',
+  install : true,
+  install_dir : join_paths(get_option('datadir'), 'vulkan', 'implicit_layer.d'),
+  install_tag : 'runtime',
+)
+
+configure_file(
+  configuration : {'library_path' : vklayer_mesa_device_select.full_path()},
+  input : 'VkLayer_MESA_device_select.json.in',
+  output : '@PLAINNAME@_dev.json',
+)
+devenv.append('VK_ADD_IMPLICIT_LAYER_PATH', meson.current_build_dir())