1 /*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19 #include "driver.h"
20
21 #include <dlfcn.h>
22 #include <malloc.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include <SurfaceFlingerProperties.h>
27 #include <android-base/properties.h>
28 #include <android/dlext.h>
29 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
30 #include <configstore/Utils.h>
31 #include <graphicsenv/GraphicsEnv.h>
32 #include <log/log.h>
33 #include <sys/prctl.h>
34 #include <utils/Timers.h>
35 #include <utils/Trace.h>
36 #include <vndksupport/linker.h>
37
38 #include <algorithm>
39 #include <array>
40 #include <climits>
41 #include <new>
42 #include <vector>
43
44 #include "stubhal.h"
45
46 using namespace android::hardware::configstore;
47 using namespace android::hardware::configstore::V1_0;
48
49 // #define ENABLE_ALLOC_CALLSTACKS 1
50 #if ENABLE_ALLOC_CALLSTACKS
51 #include <utils/CallStack.h>
52 #define ALOGD_CALLSTACK(...) \
53 do { \
54 ALOGD(__VA_ARGS__); \
55 android::CallStack callstack; \
56 callstack.update(); \
57 callstack.log(LOG_TAG, ANDROID_LOG_DEBUG, " "); \
58 } while (false)
59 #else
60 #define ALOGD_CALLSTACK(...) \
61 do { \
62 } while (false)
63 #endif
64
65 namespace vulkan {
66 namespace driver {
67
68 namespace {
69
70 class Hal {
71 public:
72 static bool Open();
73
Get()74 static const Hal& Get() { return hal_; }
Device()75 static const hwvulkan_device_t& Device() { return *Get().dev_; }
76
GetDebugReportIndex() const77 int GetDebugReportIndex() const { return debug_report_index_; }
78
79 private:
Hal()80 Hal() : dev_(nullptr), debug_report_index_(-1) {}
81 Hal(const Hal&) = delete;
82 Hal& operator=(const Hal&) = delete;
83
84 bool ShouldUnloadBuiltinDriver();
85 void UnloadBuiltinDriver();
86 bool InitDebugReportIndex();
87
88 static Hal hal_;
89
90 const hwvulkan_device_t* dev_;
91 int debug_report_index_;
92 };
93
94 class CreateInfoWrapper {
95 public:
96 CreateInfoWrapper(const VkInstanceCreateInfo& create_info,
97 uint32_t icd_api_version,
98 const VkAllocationCallbacks& allocator);
99 CreateInfoWrapper(VkPhysicalDevice physical_dev,
100 const VkDeviceCreateInfo& create_info,
101 uint32_t icd_api_version,
102 const VkAllocationCallbacks& allocator);
103 ~CreateInfoWrapper();
104
105 VkResult Validate();
106
107 const std::bitset<ProcHook::EXTENSION_COUNT>& GetHookExtensions() const;
108 const std::bitset<ProcHook::EXTENSION_COUNT>& GetHalExtensions() const;
109
110 explicit operator const VkInstanceCreateInfo*() const;
111 explicit operator const VkDeviceCreateInfo*() const;
112
113 private:
114 struct ExtensionFilter {
115 VkExtensionProperties* exts;
116 uint32_t ext_count;
117
118 const char** names;
119 uint32_t name_count;
ExtensionFiltervulkan::driver::__anon8d98a71e0111::CreateInfoWrapper::ExtensionFilter120 ExtensionFilter()
121 : exts(nullptr), ext_count(0), names(nullptr), name_count(0) {}
122 };
123
124 VkResult SanitizeApiVersion();
125 VkResult SanitizePNext();
126 VkResult SanitizeLayers();
127 VkResult SanitizeExtensions();
128
129 VkResult QueryExtensionCount(uint32_t& count) const;
130 VkResult EnumerateExtensions(uint32_t& count,
131 VkExtensionProperties* props) const;
132 VkResult InitExtensionFilter();
133 void FilterExtension(const char* name);
134
135 const bool is_instance_;
136 const VkAllocationCallbacks& allocator_;
137 const uint32_t loader_api_version_;
138 const uint32_t icd_api_version_;
139
140 VkPhysicalDevice physical_dev_;
141
142 union {
143 VkInstanceCreateInfo instance_info_;
144 VkDeviceCreateInfo dev_info_;
145 };
146
147 VkApplicationInfo application_info_;
148
149 ExtensionFilter extension_filter_;
150
151 std::bitset<ProcHook::EXTENSION_COUNT> hook_extensions_;
152 std::bitset<ProcHook::EXTENSION_COUNT> hal_extensions_;
153 };
154
155 Hal Hal::hal_;
156
157 const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{
158 "ro.hardware.vulkan",
159 "ro.board.platform",
160 }};
161 constexpr int LIB_DL_FLAGS = RTLD_LOCAL | RTLD_NOW;
162
163 // LoadDriver returns:
164 // * 0 when succeed, or
165 // * -ENOENT when fail to open binary libraries, or
166 // * -EINVAL when fail to find HAL_MODULE_INFO_SYM_AS_STR or
167 // HWVULKAN_HARDWARE_MODULE_ID in the library.
LoadDriver(android_namespace_t * library_namespace,const hwvulkan_module_t ** module)168 int LoadDriver(android_namespace_t* library_namespace,
169 const hwvulkan_module_t** module) {
170 ATRACE_CALL();
171
172 void* so = nullptr;
173 for (auto key : HAL_SUBNAME_KEY_PROPERTIES) {
174 std::string lib_name = android::base::GetProperty(key, "");
175 if (lib_name.empty())
176 continue;
177
178 lib_name = "vulkan." + lib_name + ".so";
179 if (library_namespace) {
180 // load updated driver
181 const android_dlextinfo dlextinfo = {
182 .flags = ANDROID_DLEXT_USE_NAMESPACE,
183 .library_namespace = library_namespace,
184 };
185 so = android_dlopen_ext(lib_name.c_str(), LIB_DL_FLAGS, &dlextinfo);
186 ALOGE("Could not load %s from updatable gfx driver namespace: %s.",
187 lib_name.c_str(), dlerror());
188 } else {
189 // load built-in driver
190 so = android_load_sphal_library(lib_name.c_str(), LIB_DL_FLAGS);
191 }
192 if (so)
193 break;
194 }
195 if (!so)
196 return -ENOENT;
197
198 auto hmi = static_cast<hw_module_t*>(dlsym(so, HAL_MODULE_INFO_SYM_AS_STR));
199 if (!hmi) {
200 ALOGE("couldn't find symbol '%s' in HAL library: %s", HAL_MODULE_INFO_SYM_AS_STR, dlerror());
201 dlclose(so);
202 return -EINVAL;
203 }
204 if (strcmp(hmi->id, HWVULKAN_HARDWARE_MODULE_ID) != 0) {
205 ALOGE("HAL id '%s' != '%s'", hmi->id, HWVULKAN_HARDWARE_MODULE_ID);
206 dlclose(so);
207 return -EINVAL;
208 }
209 hmi->dso = so;
210 *module = reinterpret_cast<const hwvulkan_module_t*>(hmi);
211 return 0;
212 }
213
LoadBuiltinDriver(const hwvulkan_module_t ** module)214 int LoadBuiltinDriver(const hwvulkan_module_t** module) {
215 ATRACE_CALL();
216
217 android::GraphicsEnv::getInstance().setDriverToLoad(
218 android::GpuStatsInfo::Driver::VULKAN);
219 return LoadDriver(nullptr, module);
220 }
221
LoadUpdatedDriver(const hwvulkan_module_t ** module)222 int LoadUpdatedDriver(const hwvulkan_module_t** module) {
223 ATRACE_CALL();
224
225 auto ns = android::GraphicsEnv::getInstance().getDriverNamespace();
226 if (!ns)
227 return -ENOENT;
228 android::GraphicsEnv::getInstance().setDriverToLoad(
229 android::GpuStatsInfo::Driver::VULKAN_UPDATED);
230 int result = LoadDriver(ns, module);
231 if (result != 0) {
232 LOG_ALWAYS_FATAL(
233 "couldn't find an updated Vulkan implementation from %s",
234 android::GraphicsEnv::getInstance().getDriverPath().c_str());
235 }
236 return result;
237 }
238
Open()239 bool Hal::Open() {
240 ATRACE_CALL();
241
242 const nsecs_t openTime = systemTime();
243
244 if (hal_.ShouldUnloadBuiltinDriver()) {
245 hal_.UnloadBuiltinDriver();
246 }
247
248 if (hal_.dev_)
249 return true;
250
251 // Use a stub device unless we successfully open a real HAL device.
252 hal_.dev_ = &stubhal::kDevice;
253
254 int result;
255 const hwvulkan_module_t* module = nullptr;
256
257 result = LoadUpdatedDriver(&module);
258 if (result == -ENOENT) {
259 result = LoadBuiltinDriver(&module);
260 }
261 if (result != 0) {
262 android::GraphicsEnv::getInstance().setDriverLoaded(
263 android::GpuStatsInfo::Api::API_VK, false, systemTime() - openTime);
264 ALOGV("unable to load Vulkan HAL, using stub HAL (result=%d)", result);
265 return true;
266 }
267
268
269 hwvulkan_device_t* device;
270 ATRACE_BEGIN("hwvulkan module open");
271 result =
272 module->common.methods->open(&module->common, HWVULKAN_DEVICE_0,
273 reinterpret_cast<hw_device_t**>(&device));
274 ATRACE_END();
275 if (result != 0) {
276 android::GraphicsEnv::getInstance().setDriverLoaded(
277 android::GpuStatsInfo::Api::API_VK, false, systemTime() - openTime);
278 // Any device with a Vulkan HAL should be able to open the device.
279 ALOGE("failed to open Vulkan HAL device: %s (%d)", strerror(-result),
280 result);
281 return false;
282 }
283
284 hal_.dev_ = device;
285
286 hal_.InitDebugReportIndex();
287
288 android::GraphicsEnv::getInstance().setDriverLoaded(
289 android::GpuStatsInfo::Api::API_VK, true, systemTime() - openTime);
290
291 return true;
292 }
293
ShouldUnloadBuiltinDriver()294 bool Hal::ShouldUnloadBuiltinDriver() {
295 // Should not unload since the driver was not loaded
296 if (!hal_.dev_)
297 return false;
298
299 // Should not unload if stubhal is used on the device
300 if (hal_.dev_ == &stubhal::kDevice)
301 return false;
302
303 // Unload the driver if updated driver is chosen
304 if (android::GraphicsEnv::getInstance().getDriverNamespace())
305 return true;
306
307 return false;
308 }
309
UnloadBuiltinDriver()310 void Hal::UnloadBuiltinDriver() {
311 ATRACE_CALL();
312
313 ALOGD("Unload builtin Vulkan driver.");
314
315 // Close the opened device
316 ALOG_ASSERT(!hal_.dev_->common.close(hal_.dev_->common),
317 "hw_device_t::close() failed.");
318
319 // Close the opened shared library in the hw_module_t
320 android_unload_sphal_library(hal_.dev_->common.module->dso);
321
322 hal_.dev_ = nullptr;
323 hal_.debug_report_index_ = -1;
324 }
325
InitDebugReportIndex()326 bool Hal::InitDebugReportIndex() {
327 ATRACE_CALL();
328
329 uint32_t count;
330 if (dev_->EnumerateInstanceExtensionProperties(nullptr, &count, nullptr) !=
331 VK_SUCCESS) {
332 ALOGE("failed to get HAL instance extension count");
333 return false;
334 }
335
336 VkExtensionProperties* exts = reinterpret_cast<VkExtensionProperties*>(
337 malloc(sizeof(VkExtensionProperties) * count));
338 if (!exts) {
339 ALOGE("failed to allocate HAL instance extension array");
340 return false;
341 }
342
343 if (dev_->EnumerateInstanceExtensionProperties(nullptr, &count, exts) !=
344 VK_SUCCESS) {
345 ALOGE("failed to enumerate HAL instance extensions");
346 free(exts);
347 return false;
348 }
349
350 for (uint32_t i = 0; i < count; i++) {
351 if (strcmp(exts[i].extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME) ==
352 0) {
353 debug_report_index_ = static_cast<int>(i);
354 break;
355 }
356 }
357
358 free(exts);
359
360 return true;
361 }
362
CreateInfoWrapper(const VkInstanceCreateInfo & create_info,uint32_t icd_api_version,const VkAllocationCallbacks & allocator)363 CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info,
364 uint32_t icd_api_version,
365 const VkAllocationCallbacks& allocator)
366 : is_instance_(true),
367 allocator_(allocator),
368 loader_api_version_(VK_API_VERSION_1_3),
369 icd_api_version_(icd_api_version),
370 physical_dev_(VK_NULL_HANDLE),
371 instance_info_(create_info),
372 extension_filter_() {}
373
CreateInfoWrapper(VkPhysicalDevice physical_dev,const VkDeviceCreateInfo & create_info,uint32_t icd_api_version,const VkAllocationCallbacks & allocator)374 CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev,
375 const VkDeviceCreateInfo& create_info,
376 uint32_t icd_api_version,
377 const VkAllocationCallbacks& allocator)
378 : is_instance_(false),
379 allocator_(allocator),
380 loader_api_version_(VK_API_VERSION_1_3),
381 icd_api_version_(icd_api_version),
382 physical_dev_(physical_dev),
383 dev_info_(create_info),
384 extension_filter_() {}
385
~CreateInfoWrapper()386 CreateInfoWrapper::~CreateInfoWrapper() {
387 allocator_.pfnFree(allocator_.pUserData, extension_filter_.exts);
388 allocator_.pfnFree(allocator_.pUserData, extension_filter_.names);
389 }
390
Validate()391 VkResult CreateInfoWrapper::Validate() {
392 VkResult result = SanitizeApiVersion();
393 if (result == VK_SUCCESS)
394 result = SanitizePNext();
395 if (result == VK_SUCCESS)
396 result = SanitizeLayers();
397 if (result == VK_SUCCESS)
398 result = SanitizeExtensions();
399
400 return result;
401 }
402
403 const std::bitset<ProcHook::EXTENSION_COUNT>&
GetHookExtensions() const404 CreateInfoWrapper::GetHookExtensions() const {
405 return hook_extensions_;
406 }
407
408 const std::bitset<ProcHook::EXTENSION_COUNT>&
GetHalExtensions() const409 CreateInfoWrapper::GetHalExtensions() const {
410 return hal_extensions_;
411 }
412
operator const VkInstanceCreateInfo*() const413 CreateInfoWrapper::operator const VkInstanceCreateInfo*() const {
414 return &instance_info_;
415 }
416
operator const VkDeviceCreateInfo*() const417 CreateInfoWrapper::operator const VkDeviceCreateInfo*() const {
418 return &dev_info_;
419 }
420
SanitizeApiVersion()421 VkResult CreateInfoWrapper::SanitizeApiVersion() {
422 if (!is_instance_ || !instance_info_.pApplicationInfo)
423 return VK_SUCCESS;
424
425 if (icd_api_version_ > VK_API_VERSION_1_0 ||
426 instance_info_.pApplicationInfo->apiVersion < VK_API_VERSION_1_1)
427 return VK_SUCCESS;
428
429 // override apiVersion to avoid error return from 1.0 icd
430 application_info_ = *instance_info_.pApplicationInfo;
431 application_info_.apiVersion = VK_API_VERSION_1_0;
432 instance_info_.pApplicationInfo = &application_info_;
433
434 return VK_SUCCESS;
435 }
436
SanitizePNext()437 VkResult CreateInfoWrapper::SanitizePNext() {
438 const struct StructHeader {
439 VkStructureType type;
440 const void* next;
441 } * header;
442
443 if (is_instance_) {
444 header = reinterpret_cast<const StructHeader*>(instance_info_.pNext);
445
446 // skip leading VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFOs
447 while (header &&
448 header->type == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO)
449 header = reinterpret_cast<const StructHeader*>(header->next);
450
451 instance_info_.pNext = header;
452 } else {
453 header = reinterpret_cast<const StructHeader*>(dev_info_.pNext);
454
455 // skip leading VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFOs
456 while (header &&
457 header->type == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO)
458 header = reinterpret_cast<const StructHeader*>(header->next);
459
460 dev_info_.pNext = header;
461 }
462
463 return VK_SUCCESS;
464 }
465
SanitizeLayers()466 VkResult CreateInfoWrapper::SanitizeLayers() {
467 auto& layer_names = (is_instance_) ? instance_info_.ppEnabledLayerNames
468 : dev_info_.ppEnabledLayerNames;
469 auto& layer_count = (is_instance_) ? instance_info_.enabledLayerCount
470 : dev_info_.enabledLayerCount;
471
472 // remove all layers
473 layer_names = nullptr;
474 layer_count = 0;
475
476 return VK_SUCCESS;
477 }
478
SanitizeExtensions()479 VkResult CreateInfoWrapper::SanitizeExtensions() {
480 auto& ext_names = (is_instance_) ? instance_info_.ppEnabledExtensionNames
481 : dev_info_.ppEnabledExtensionNames;
482 auto& ext_count = (is_instance_) ? instance_info_.enabledExtensionCount
483 : dev_info_.enabledExtensionCount;
484
485 VkResult result = InitExtensionFilter();
486 if (result != VK_SUCCESS)
487 return result;
488
489 if (is_instance_ && icd_api_version_ < loader_api_version_) {
490 for (uint32_t i = 0; i < ext_count; i++) {
491 // Upon api downgrade, skip the promoted instance extensions in the
492 // first pass to avoid duplicate extensions.
493 const std::optional<uint32_t> version =
494 GetInstanceExtensionPromotedVersion(ext_names[i]);
495 if (version && *version > icd_api_version_ &&
496 *version <= loader_api_version_)
497 continue;
498
499 FilterExtension(ext_names[i]);
500 }
501
502 // Enable the required extensions to support core functionalities.
503 const auto promoted_extensions = GetPromotedInstanceExtensions(
504 icd_api_version_, loader_api_version_);
505 for (const auto& promoted_extension : promoted_extensions)
506 FilterExtension(promoted_extension);
507 } else {
508 for (uint32_t i = 0; i < ext_count; i++)
509 FilterExtension(ext_names[i]);
510 }
511
512 // Enable device extensions that contain physical-device commands, so that
513 // vkGetInstanceProcAddr will return those physical-device commands.
514 if (is_instance_) {
515 hook_extensions_.set(ProcHook::KHR_swapchain);
516 }
517
518 const uint32_t api_version =
519 is_instance_ ? loader_api_version_
520 : std::min(icd_api_version_, loader_api_version_);
521 switch (api_version) {
522 case VK_API_VERSION_1_3:
523 hook_extensions_.set(ProcHook::EXTENSION_CORE_1_3);
524 hal_extensions_.set(ProcHook::EXTENSION_CORE_1_3);
525 [[clang::fallthrough]];
526 case VK_API_VERSION_1_2:
527 hook_extensions_.set(ProcHook::EXTENSION_CORE_1_2);
528 hal_extensions_.set(ProcHook::EXTENSION_CORE_1_2);
529 [[clang::fallthrough]];
530 case VK_API_VERSION_1_1:
531 hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1);
532 hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1);
533 [[clang::fallthrough]];
534 case VK_API_VERSION_1_0:
535 hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0);
536 hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0);
537 break;
538 default:
539 ALOGE("Unknown API version[%u]", api_version);
540 break;
541 }
542
543 ext_names = extension_filter_.names;
544 ext_count = extension_filter_.name_count;
545
546 return VK_SUCCESS;
547 }
548
QueryExtensionCount(uint32_t & count) const549 VkResult CreateInfoWrapper::QueryExtensionCount(uint32_t& count) const {
550 if (is_instance_) {
551 return Hal::Device().EnumerateInstanceExtensionProperties(
552 nullptr, &count, nullptr);
553 } else {
554 const auto& driver = GetData(physical_dev_).driver;
555 return driver.EnumerateDeviceExtensionProperties(physical_dev_, nullptr,
556 &count, nullptr);
557 }
558 }
559
EnumerateExtensions(uint32_t & count,VkExtensionProperties * props) const560 VkResult CreateInfoWrapper::EnumerateExtensions(
561 uint32_t& count,
562 VkExtensionProperties* props) const {
563 if (is_instance_) {
564 return Hal::Device().EnumerateInstanceExtensionProperties(
565 nullptr, &count, props);
566 } else {
567 const auto& driver = GetData(physical_dev_).driver;
568 return driver.EnumerateDeviceExtensionProperties(physical_dev_, nullptr,
569 &count, props);
570 }
571 }
572
InitExtensionFilter()573 VkResult CreateInfoWrapper::InitExtensionFilter() {
574 // query extension count
575 uint32_t count;
576 VkResult result = QueryExtensionCount(count);
577 if (result != VK_SUCCESS || count == 0)
578 return result;
579
580 auto& filter = extension_filter_;
581 filter.exts =
582 reinterpret_cast<VkExtensionProperties*>(allocator_.pfnAllocation(
583 allocator_.pUserData, sizeof(VkExtensionProperties) * count,
584 alignof(VkExtensionProperties),
585 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
586 if (!filter.exts)
587 return VK_ERROR_OUT_OF_HOST_MEMORY;
588
589 // enumerate extensions
590 result = EnumerateExtensions(count, filter.exts);
591 if (result != VK_SUCCESS && result != VK_INCOMPLETE)
592 return result;
593
594 if (!count)
595 return VK_SUCCESS;
596
597 filter.ext_count = count;
598
599 // allocate name array
600 if (is_instance_) {
601 uint32_t enabled_ext_count = instance_info_.enabledExtensionCount;
602
603 // It requires enabling additional promoted extensions to downgrade api,
604 // so we reserve enough space here.
605 if (icd_api_version_ < loader_api_version_) {
606 enabled_ext_count += CountPromotedInstanceExtensions(
607 icd_api_version_, loader_api_version_);
608 }
609
610 count = std::min(filter.ext_count, enabled_ext_count);
611 } else {
612 count = std::min(filter.ext_count, dev_info_.enabledExtensionCount);
613 }
614
615 if (!count)
616 return VK_SUCCESS;
617
618 filter.names = reinterpret_cast<const char**>(allocator_.pfnAllocation(
619 allocator_.pUserData, sizeof(const char*) * count, alignof(const char*),
620 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
621 if (!filter.names)
622 return VK_ERROR_OUT_OF_HOST_MEMORY;
623
624 return VK_SUCCESS;
625 }
626
FilterExtension(const char * name)627 void CreateInfoWrapper::FilterExtension(const char* name) {
628 auto& filter = extension_filter_;
629
630 ProcHook::Extension ext_bit = GetProcHookExtension(name);
631 if (is_instance_) {
632 switch (ext_bit) {
633 case ProcHook::KHR_android_surface:
634 case ProcHook::KHR_surface:
635 case ProcHook::KHR_surface_protected_capabilities:
636 case ProcHook::EXT_swapchain_colorspace:
637 case ProcHook::KHR_get_surface_capabilities2:
638 case ProcHook::GOOGLE_surfaceless_query:
639 case ProcHook::EXT_surface_maintenance1:
640 hook_extensions_.set(ext_bit);
641 // return now as these extensions do not require HAL support
642 return;
643 case ProcHook::EXT_debug_report:
644 // both we and HAL can take part in
645 hook_extensions_.set(ext_bit);
646 break;
647 case ProcHook::KHR_get_physical_device_properties2:
648 case ProcHook::KHR_device_group_creation:
649 case ProcHook::KHR_external_memory_capabilities:
650 case ProcHook::KHR_external_semaphore_capabilities:
651 case ProcHook::KHR_external_fence_capabilities:
652 case ProcHook::EXTENSION_UNKNOWN:
653 // Extensions we don't need to do anything about at this level
654 break;
655
656 case ProcHook::KHR_bind_memory2:
657 case ProcHook::KHR_incremental_present:
658 case ProcHook::KHR_shared_presentable_image:
659 case ProcHook::KHR_swapchain:
660 case ProcHook::EXT_hdr_metadata:
661 case ProcHook::EXT_swapchain_maintenance1:
662 case ProcHook::ANDROID_external_memory_android_hardware_buffer:
663 case ProcHook::ANDROID_native_buffer:
664 case ProcHook::GOOGLE_display_timing:
665 case ProcHook::KHR_external_fence_fd:
666 case ProcHook::EXTENSION_CORE_1_0:
667 case ProcHook::EXTENSION_CORE_1_1:
668 case ProcHook::EXTENSION_CORE_1_2:
669 case ProcHook::EXTENSION_CORE_1_3:
670 case ProcHook::EXTENSION_COUNT:
671 // Device and meta extensions. If we ever get here it's a bug in
672 // our code. But enumerating them lets us avoid having a default
673 // case, and default hides other bugs.
674 ALOGE(
675 "CreateInfoWrapper::FilterExtension: invalid instance "
676 "extension '%s'. FIX ME",
677 name);
678 return;
679
680 // Don't use a default case. Without it, -Wswitch will tell us
681 // at compile time if someone adds a new ProcHook extension but
682 // doesn't handle it above. That's a real bug that has
683 // not-immediately-obvious effects.
684 //
685 // default:
686 // break;
687 }
688 } else {
689 switch (ext_bit) {
690 case ProcHook::KHR_swapchain:
691 // map VK_KHR_swapchain to VK_ANDROID_native_buffer
692 name = VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME;
693 ext_bit = ProcHook::ANDROID_native_buffer;
694 break;
695 case ProcHook::KHR_incremental_present:
696 case ProcHook::KHR_shared_presentable_image:
697 case ProcHook::GOOGLE_display_timing:
698 hook_extensions_.set(ext_bit);
699 // return now as these extensions do not require HAL support
700 return;
701 case ProcHook::EXT_swapchain_maintenance1:
702 // map VK_KHR_swapchain_maintenance1 to KHR_external_fence_fd
703 name = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME;
704 ext_bit = ProcHook::KHR_external_fence_fd;
705 break;
706 case ProcHook::EXT_hdr_metadata:
707 case ProcHook::KHR_bind_memory2:
708 hook_extensions_.set(ext_bit);
709 break;
710 case ProcHook::ANDROID_external_memory_android_hardware_buffer:
711 case ProcHook::KHR_external_fence_fd:
712 case ProcHook::EXTENSION_UNKNOWN:
713 // Extensions we don't need to do anything about at this level
714 break;
715
716 case ProcHook::KHR_android_surface:
717 case ProcHook::KHR_get_physical_device_properties2:
718 case ProcHook::KHR_device_group_creation:
719 case ProcHook::KHR_external_memory_capabilities:
720 case ProcHook::KHR_external_semaphore_capabilities:
721 case ProcHook::KHR_external_fence_capabilities:
722 case ProcHook::KHR_get_surface_capabilities2:
723 case ProcHook::KHR_surface:
724 case ProcHook::KHR_surface_protected_capabilities:
725 case ProcHook::EXT_debug_report:
726 case ProcHook::EXT_swapchain_colorspace:
727 case ProcHook::EXT_surface_maintenance1:
728 case ProcHook::GOOGLE_surfaceless_query:
729 case ProcHook::ANDROID_native_buffer:
730 case ProcHook::EXTENSION_CORE_1_0:
731 case ProcHook::EXTENSION_CORE_1_1:
732 case ProcHook::EXTENSION_CORE_1_2:
733 case ProcHook::EXTENSION_CORE_1_3:
734 case ProcHook::EXTENSION_COUNT:
735 // Instance and meta extensions. If we ever get here it's a bug
736 // in our code. But enumerating them lets us avoid having a
737 // default case, and default hides other bugs.
738 ALOGE(
739 "CreateInfoWrapper::FilterExtension: invalid device "
740 "extension '%s'. FIX ME",
741 name);
742 return;
743
744 // Don't use a default case. Without it, -Wswitch will tell us
745 // at compile time if someone adds a new ProcHook extension but
746 // doesn't handle it above. That's a real bug that has
747 // not-immediately-obvious effects.
748 //
749 // default:
750 // break;
751 }
752 }
753
754 for (uint32_t i = 0; i < filter.ext_count; i++) {
755 const VkExtensionProperties& props = filter.exts[i];
756 // ignore unknown extensions
757 if (strcmp(name, props.extensionName) != 0)
758 continue;
759
760 if (ext_bit != ProcHook::EXTENSION_UNKNOWN &&
761 hal_extensions_.test(ext_bit)) {
762 ALOGI("CreateInfoWrapper::FilterExtension: already have '%s'.", name);
763 continue;
764 }
765
766 // Ignore duplicate extensions (see: b/288929054)
767 bool duplicate_entry = false;
768 for (uint32_t j = 0; j < filter.name_count; j++) {
769 if (strcmp(name, filter.names[j]) == 0) {
770 duplicate_entry = true;
771 break;
772 }
773 }
774 if (duplicate_entry == true)
775 continue;
776
777 filter.names[filter.name_count++] = name;
778 if (ext_bit != ProcHook::EXTENSION_UNKNOWN) {
779 if (ext_bit == ProcHook::ANDROID_native_buffer)
780 hook_extensions_.set(ProcHook::KHR_swapchain);
781 if (ext_bit == ProcHook::KHR_external_fence_fd)
782 hook_extensions_.set(ProcHook::EXT_swapchain_maintenance1);
783
784 hal_extensions_.set(ext_bit);
785 }
786
787 break;
788 }
789 }
790
DefaultAllocate(void *,size_t size,size_t alignment,VkSystemAllocationScope)791 VKAPI_ATTR void* DefaultAllocate(void*,
792 size_t size,
793 size_t alignment,
794 VkSystemAllocationScope) {
795 void* ptr = nullptr;
796 // Vulkan requires 'alignment' to be a power of two, but posix_memalign
797 // additionally requires that it be at least sizeof(void*).
798 int ret = posix_memalign(&ptr, std::max(alignment, sizeof(void*)), size);
799 ALOGD_CALLSTACK("Allocate: size=%zu align=%zu => (%d) %p", size, alignment,
800 ret, ptr);
801 return ret == 0 ? ptr : nullptr;
802 }
803
DefaultReallocate(void *,void * ptr,size_t size,size_t alignment,VkSystemAllocationScope)804 VKAPI_ATTR void* DefaultReallocate(void*,
805 void* ptr,
806 size_t size,
807 size_t alignment,
808 VkSystemAllocationScope) {
809 if (size == 0) {
810 free(ptr);
811 return nullptr;
812 }
813
814 // TODO(b/143295633): Right now we never shrink allocations; if the new
815 // request is smaller than the existing chunk, we just continue using it.
816 // Right now the loader never reallocs, so this doesn't matter. If that
817 // changes, or if this code is copied into some other project, this should
818 // probably have a heuristic to allocate-copy-free when doing so will save
819 // "enough" space.
820 size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
821 if (size <= old_size)
822 return ptr;
823
824 void* new_ptr = nullptr;
825 if (posix_memalign(&new_ptr, std::max(alignment, sizeof(void*)), size) != 0)
826 return nullptr;
827 if (ptr) {
828 memcpy(new_ptr, ptr, std::min(old_size, size));
829 free(ptr);
830 }
831 return new_ptr;
832 }
833
DefaultFree(void *,void * ptr)834 VKAPI_ATTR void DefaultFree(void*, void* ptr) {
835 ALOGD_CALLSTACK("Free: %p", ptr);
836 free(ptr);
837 }
838
AllocateInstanceData(const VkAllocationCallbacks & allocator)839 InstanceData* AllocateInstanceData(const VkAllocationCallbacks& allocator) {
840 void* data_mem = allocator.pfnAllocation(
841 allocator.pUserData, sizeof(InstanceData), alignof(InstanceData),
842 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
843 if (!data_mem)
844 return nullptr;
845
846 return new (data_mem) InstanceData(allocator);
847 }
848
FreeInstanceData(InstanceData * data,const VkAllocationCallbacks & allocator)849 void FreeInstanceData(InstanceData* data,
850 const VkAllocationCallbacks& allocator) {
851 data->~InstanceData();
852 allocator.pfnFree(allocator.pUserData, data);
853 }
854
AllocateDeviceData(const VkAllocationCallbacks & allocator,const DebugReportCallbackList & debug_report_callbacks)855 DeviceData* AllocateDeviceData(
856 const VkAllocationCallbacks& allocator,
857 const DebugReportCallbackList& debug_report_callbacks) {
858 void* data_mem = allocator.pfnAllocation(
859 allocator.pUserData, sizeof(DeviceData), alignof(DeviceData),
860 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
861 if (!data_mem)
862 return nullptr;
863
864 return new (data_mem) DeviceData(allocator, debug_report_callbacks);
865 }
866
FreeDeviceData(DeviceData * data,const VkAllocationCallbacks & allocator)867 void FreeDeviceData(DeviceData* data, const VkAllocationCallbacks& allocator) {
868 data->~DeviceData();
869 allocator.pfnFree(allocator.pUserData, data);
870 }
871
872 } // anonymous namespace
873
OpenHAL()874 bool OpenHAL() {
875 return Hal::Open();
876 }
877
GetDefaultAllocator()878 const VkAllocationCallbacks& GetDefaultAllocator() {
879 static const VkAllocationCallbacks kDefaultAllocCallbacks = {
880 .pUserData = nullptr,
881 .pfnAllocation = DefaultAllocate,
882 .pfnReallocation = DefaultReallocate,
883 .pfnFree = DefaultFree,
884 };
885
886 return kDefaultAllocCallbacks;
887 }
888
GetInstanceProcAddr(VkInstance instance,const char * pName)889 PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName) {
890 const ProcHook* hook = GetProcHook(pName);
891 if (!hook)
892 return Hal::Device().GetInstanceProcAddr(instance, pName);
893
894 if (!instance) {
895 if (hook->type == ProcHook::GLOBAL)
896 return hook->proc;
897
898 // v0 layers expect
899 //
900 // vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkCreateDevice");
901 //
902 // to work.
903 if (strcmp(pName, "vkCreateDevice") == 0)
904 return hook->proc;
905
906 ALOGE(
907 "internal vkGetInstanceProcAddr called for %s without an instance",
908 pName);
909
910 return nullptr;
911 }
912
913 PFN_vkVoidFunction proc;
914
915 switch (hook->type) {
916 case ProcHook::INSTANCE:
917 proc = (GetData(instance).hook_extensions[hook->extension])
918 ? hook->proc
919 : nullptr;
920 break;
921 case ProcHook::DEVICE:
922 proc = (hook->extension == ProcHook::EXTENSION_CORE_1_0)
923 ? hook->proc
924 : hook->checked_proc;
925 break;
926 default:
927 ALOGE(
928 "internal vkGetInstanceProcAddr called for %s with an instance",
929 pName);
930 proc = nullptr;
931 break;
932 }
933
934 return proc;
935 }
936
GetDeviceProcAddr(VkDevice device,const char * pName)937 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName) {
938 const ProcHook* hook = GetProcHook(pName);
939 if (!hook)
940 return GetData(device).driver.GetDeviceProcAddr(device, pName);
941
942 if (hook->type != ProcHook::DEVICE) {
943 ALOGE("internal vkGetDeviceProcAddr called for %s", pName);
944 return nullptr;
945 }
946
947 return (GetData(device).hook_extensions[hook->extension]) ? hook->proc
948 : nullptr;
949 }
950
EnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)951 VkResult EnumerateInstanceExtensionProperties(
952 const char* pLayerName,
953 uint32_t* pPropertyCount,
954 VkExtensionProperties* pProperties) {
955 std::vector<VkExtensionProperties> loader_extensions;
956 loader_extensions.push_back(
957 {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION});
958 loader_extensions.push_back(
959 {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME,
960 VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION});
961 loader_extensions.push_back({
962 VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
963 VK_KHR_ANDROID_SURFACE_SPEC_VERSION});
964 loader_extensions.push_back({
965 VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME,
966 VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION});
967 loader_extensions.push_back(
968 {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,
969 VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION});
970 loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME,
971 VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION});
972 loader_extensions.push_back({
973 VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME,
974 VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION});
975
976 static const VkExtensionProperties loader_debug_report_extension = {
977 VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION,
978 };
979
980 // enumerate our extensions first
981 if (!pLayerName && pProperties) {
982 uint32_t count = std::min(
983 *pPropertyCount, static_cast<uint32_t>(loader_extensions.size()));
984
985 std::copy_n(loader_extensions.data(), count, pProperties);
986
987 if (count < loader_extensions.size()) {
988 *pPropertyCount = count;
989 return VK_INCOMPLETE;
990 }
991
992 pProperties += count;
993 *pPropertyCount -= count;
994
995 if (Hal::Get().GetDebugReportIndex() < 0) {
996 if (!*pPropertyCount) {
997 *pPropertyCount = count;
998 return VK_INCOMPLETE;
999 }
1000
1001 pProperties[0] = loader_debug_report_extension;
1002 pProperties += 1;
1003 *pPropertyCount -= 1;
1004 }
1005 }
1006
1007 ATRACE_BEGIN("driver.EnumerateInstanceExtensionProperties");
1008 VkResult result = Hal::Device().EnumerateInstanceExtensionProperties(
1009 pLayerName, pPropertyCount, pProperties);
1010 ATRACE_END();
1011
1012 if (!pLayerName && (result == VK_SUCCESS || result == VK_INCOMPLETE)) {
1013 int idx = Hal::Get().GetDebugReportIndex();
1014 if (idx < 0) {
1015 *pPropertyCount += 1;
1016 } else if (pProperties &&
1017 static_cast<uint32_t>(idx) < *pPropertyCount) {
1018 pProperties[idx].specVersion =
1019 std::min(pProperties[idx].specVersion,
1020 loader_debug_report_extension.specVersion);
1021 }
1022
1023 *pPropertyCount += loader_extensions.size();
1024 }
1025
1026 return result;
1027 }
1028
QueryPresentationProperties(VkPhysicalDevice physicalDevice,VkPhysicalDevicePresentationPropertiesANDROID * presentation_properties)1029 void QueryPresentationProperties(
1030 VkPhysicalDevice physicalDevice,
1031 VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties) {
1032 ATRACE_CALL();
1033
1034 // Request the android-specific presentation properties via GPDP2
1035 VkPhysicalDeviceProperties2 properties = {
1036 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
1037 presentation_properties,
1038 {},
1039 };
1040
1041 #pragma clang diagnostic push
1042 #pragma clang diagnostic ignored "-Wold-style-cast"
1043 presentation_properties->sType =
1044 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID;
1045 #pragma clang diagnostic pop
1046 presentation_properties->pNext = nullptr;
1047 presentation_properties->sharedImage = VK_FALSE;
1048
1049 const auto& driver = GetData(physicalDevice).driver;
1050
1051 if (driver.GetPhysicalDeviceProperties2) {
1052 // >= 1.1 driver, supports core GPDP2 entrypoint.
1053 driver.GetPhysicalDeviceProperties2(physicalDevice, &properties);
1054 } else if (driver.GetPhysicalDeviceProperties2KHR) {
1055 // Old driver, but may support presentation properties
1056 // if we have the GPDP2 extension. Otherwise, no presentation
1057 // properties supported.
1058 driver.GetPhysicalDeviceProperties2KHR(physicalDevice, &properties);
1059 }
1060 }
1061
GetAndroidNativeBufferSpecVersion9Support(VkPhysicalDevice physicalDevice,bool & support)1062 VkResult GetAndroidNativeBufferSpecVersion9Support(
1063 VkPhysicalDevice physicalDevice,
1064 bool& support) {
1065 support = false;
1066
1067 const InstanceData& data = GetData(physicalDevice);
1068
1069 // Call to get propertyCount
1070 uint32_t propertyCount = 0;
1071 ATRACE_BEGIN("driver.EnumerateDeviceExtensionProperties");
1072 VkResult result = data.driver.EnumerateDeviceExtensionProperties(
1073 physicalDevice, nullptr, &propertyCount, nullptr);
1074 ATRACE_END();
1075
1076 if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
1077 return result;
1078 }
1079
1080 // Call to enumerate properties
1081 std::vector<VkExtensionProperties> properties(propertyCount);
1082 ATRACE_BEGIN("driver.EnumerateDeviceExtensionProperties");
1083 result = data.driver.EnumerateDeviceExtensionProperties(
1084 physicalDevice, nullptr, &propertyCount, properties.data());
1085 ATRACE_END();
1086
1087 if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
1088 return result;
1089 }
1090
1091 for (uint32_t i = 0; i < propertyCount; i++) {
1092 auto& prop = properties[i];
1093
1094 if (strcmp(prop.extensionName,
1095 VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME) != 0)
1096 continue;
1097
1098 if (prop.specVersion >= 9) {
1099 support = true;
1100 return result;
1101 }
1102 }
1103
1104 return result;
1105 }
1106
CanSupportSwapchainMaintenance1Extension(VkPhysicalDevice physicalDevice)1107 bool CanSupportSwapchainMaintenance1Extension(VkPhysicalDevice physicalDevice) {
1108 const auto& driver = GetData(physicalDevice).driver;
1109 if (!driver.GetPhysicalDeviceExternalFenceProperties)
1110 return false;
1111
1112 // Requires support for external fences imported from sync fds.
1113 // This is _almost_ universal on Android, but may be missing on
1114 // some extremely old drivers, or on strange implementations like
1115 // cuttlefish.
1116 VkPhysicalDeviceExternalFenceInfo fenceInfo = {
1117 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
1118 nullptr,
1119 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
1120 };
1121 VkExternalFenceProperties fenceProperties = {
1122 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
1123 nullptr,
1124 0, 0, 0
1125 };
1126
1127 GetPhysicalDeviceExternalFenceProperties(physicalDevice, &fenceInfo, &fenceProperties);
1128 if (fenceProperties.externalFenceFeatures & VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT)
1129 return true;
1130
1131 return false;
1132 }
1133
EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)1134 VkResult EnumerateDeviceExtensionProperties(
1135 VkPhysicalDevice physicalDevice,
1136 const char* pLayerName,
1137 uint32_t* pPropertyCount,
1138 VkExtensionProperties* pProperties) {
1139 const InstanceData& data = GetData(physicalDevice);
1140 // extensions that are unconditionally exposed by the loader
1141 std::vector<VkExtensionProperties> loader_extensions;
1142 loader_extensions.push_back({
1143 VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME,
1144 VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION});
1145
1146 bool hdrBoardConfig = android::sysprop::has_HDR_display(false);
1147 if (hdrBoardConfig) {
1148 loader_extensions.push_back({VK_EXT_HDR_METADATA_EXTENSION_NAME,
1149 VK_EXT_HDR_METADATA_SPEC_VERSION});
1150 }
1151
1152 VkPhysicalDevicePresentationPropertiesANDROID presentation_properties;
1153 QueryPresentationProperties(physicalDevice, &presentation_properties);
1154 if (presentation_properties.sharedImage) {
1155 loader_extensions.push_back({
1156 VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME,
1157 VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION});
1158 }
1159
1160 // conditionally add VK_GOOGLE_display_timing if present timestamps are
1161 // supported by the driver:
1162 if (android::base::GetBoolProperty("service.sf.present_timestamp", false)) {
1163 loader_extensions.push_back({
1164 VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME,
1165 VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION});
1166 }
1167
1168 // Conditionally add VK_EXT_IMAGE_COMPRESSION_CONTROL* if feature and ANB
1169 // support is provided by the driver
1170 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
1171 swapchainCompFeats = {};
1172 swapchainCompFeats.sType =
1173 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
1174 swapchainCompFeats.pNext = nullptr;
1175 swapchainCompFeats.imageCompressionControlSwapchain = false;
1176 VkPhysicalDeviceImageCompressionControlFeaturesEXT imageCompFeats = {};
1177 imageCompFeats.sType =
1178 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
1179 imageCompFeats.pNext = &swapchainCompFeats;
1180 imageCompFeats.imageCompressionControl = false;
1181
1182 VkPhysicalDeviceFeatures2 feats2 = {};
1183 feats2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1184 feats2.pNext = &imageCompFeats;
1185
1186 const auto& driver = GetData(physicalDevice).driver;
1187 if (driver.GetPhysicalDeviceFeatures2 ||
1188 driver.GetPhysicalDeviceFeatures2KHR) {
1189 GetPhysicalDeviceFeatures2(physicalDevice, &feats2);
1190 }
1191
1192 bool anb9 = false;
1193 VkResult result =
1194 GetAndroidNativeBufferSpecVersion9Support(physicalDevice, anb9);
1195
1196 if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
1197 return result;
1198 }
1199
1200 if (anb9 && imageCompFeats.imageCompressionControl) {
1201 loader_extensions.push_back(
1202 {VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME,
1203 VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION});
1204 }
1205 if (anb9 && swapchainCompFeats.imageCompressionControlSwapchain) {
1206 loader_extensions.push_back(
1207 {VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME,
1208 VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION});
1209 }
1210
1211 if (CanSupportSwapchainMaintenance1Extension(physicalDevice)) {
1212 loader_extensions.push_back({
1213 VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME,
1214 VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION});
1215 }
1216
1217 // enumerate our extensions first
1218 if (!pLayerName && pProperties) {
1219 uint32_t count = std::min(
1220 *pPropertyCount, static_cast<uint32_t>(loader_extensions.size()));
1221
1222 std::copy_n(loader_extensions.data(), count, pProperties);
1223
1224 if (count < loader_extensions.size()) {
1225 *pPropertyCount = count;
1226 return VK_INCOMPLETE;
1227 }
1228
1229 pProperties += count;
1230 *pPropertyCount -= count;
1231 }
1232
1233 ATRACE_BEGIN("driver.EnumerateDeviceExtensionProperties");
1234 result = data.driver.EnumerateDeviceExtensionProperties(
1235 physicalDevice, pLayerName, pPropertyCount, pProperties);
1236 ATRACE_END();
1237
1238 if (pProperties) {
1239 // map VK_ANDROID_native_buffer to VK_KHR_swapchain
1240 for (uint32_t i = 0; i < *pPropertyCount; i++) {
1241 auto& prop = pProperties[i];
1242
1243 if (strcmp(prop.extensionName,
1244 VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME) != 0)
1245 continue;
1246
1247 memcpy(prop.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME,
1248 sizeof(VK_KHR_SWAPCHAIN_EXTENSION_NAME));
1249
1250 if (prop.specVersion >= 8) {
1251 prop.specVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION;
1252 } else {
1253 prop.specVersion = 68;
1254 }
1255 }
1256 }
1257
1258 // restore loader extension count
1259 if (!pLayerName && (result == VK_SUCCESS || result == VK_INCOMPLETE)) {
1260 *pPropertyCount += loader_extensions.size();
1261 }
1262
1263 return result;
1264 }
1265
CreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance)1266 VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
1267 const VkAllocationCallbacks* pAllocator,
1268 VkInstance* pInstance) {
1269 const VkAllocationCallbacks& data_allocator =
1270 (pAllocator) ? *pAllocator : GetDefaultAllocator();
1271
1272 VkResult result = VK_SUCCESS;
1273 uint32_t icd_api_version = VK_API_VERSION_1_0;
1274 PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version =
1275 reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
1276 Hal::Device().GetInstanceProcAddr(nullptr,
1277 "vkEnumerateInstanceVersion"));
1278 if (pfn_enumerate_instance_version) {
1279 ATRACE_BEGIN("pfn_enumerate_instance_version");
1280 result = (*pfn_enumerate_instance_version)(&icd_api_version);
1281 ATRACE_END();
1282 if (result != VK_SUCCESS)
1283 return result;
1284
1285 icd_api_version ^= VK_API_VERSION_PATCH(icd_api_version);
1286 }
1287
1288 CreateInfoWrapper wrapper(*pCreateInfo, icd_api_version, data_allocator);
1289 result = wrapper.Validate();
1290 if (result != VK_SUCCESS)
1291 return result;
1292
1293 InstanceData* data = AllocateInstanceData(data_allocator);
1294 if (!data)
1295 return VK_ERROR_OUT_OF_HOST_MEMORY;
1296
1297 data->hook_extensions |= wrapper.GetHookExtensions();
1298
1299 // call into the driver
1300 VkInstance instance;
1301 ATRACE_BEGIN("driver.CreateInstance");
1302 result = Hal::Device().CreateInstance(
1303 static_cast<const VkInstanceCreateInfo*>(wrapper), pAllocator,
1304 &instance);
1305 ATRACE_END();
1306 if (result != VK_SUCCESS) {
1307 FreeInstanceData(data, data_allocator);
1308 return result;
1309 }
1310
1311 // initialize InstanceDriverTable
1312 if (!SetData(instance, *data) ||
1313 !InitDriverTable(instance, Hal::Device().GetInstanceProcAddr,
1314 wrapper.GetHalExtensions())) {
1315 data->driver.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
1316 Hal::Device().GetInstanceProcAddr(instance, "vkDestroyInstance"));
1317 if (data->driver.DestroyInstance)
1318 data->driver.DestroyInstance(instance, pAllocator);
1319
1320 FreeInstanceData(data, data_allocator);
1321
1322 return VK_ERROR_INCOMPATIBLE_DRIVER;
1323 }
1324
1325 data->get_device_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
1326 Hal::Device().GetInstanceProcAddr(instance, "vkGetDeviceProcAddr"));
1327 if (!data->get_device_proc_addr) {
1328 data->driver.DestroyInstance(instance, pAllocator);
1329 FreeInstanceData(data, data_allocator);
1330
1331 return VK_ERROR_INCOMPATIBLE_DRIVER;
1332 }
1333
1334 // TODO(b/259516419) avoid getting stats from hwui
1335 // const bool reportStats = (pCreateInfo->pApplicationInfo == nullptr )
1336 // || (strcmp("android framework",
1337 // pCreateInfo->pApplicationInfo->pEngineName) != 0);
1338 const bool reportStats = true;
1339 if (reportStats) {
1340 // Set stats for Vulkan api version requested with application info
1341 if (pCreateInfo->pApplicationInfo) {
1342 const uint32_t vulkanApiVersion =
1343 pCreateInfo->pApplicationInfo->apiVersion;
1344 android::GraphicsEnv::getInstance().setTargetStats(
1345 android::GpuStatsInfo::Stats::CREATED_VULKAN_API_VERSION,
1346 vulkanApiVersion);
1347 }
1348
1349 // Update stats for the extensions requested
1350 android::GraphicsEnv::getInstance().setVulkanInstanceExtensions(
1351 pCreateInfo->enabledExtensionCount,
1352 pCreateInfo->ppEnabledExtensionNames);
1353 }
1354
1355 *pInstance = instance;
1356
1357 return VK_SUCCESS;
1358 }
1359
DestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator)1360 void DestroyInstance(VkInstance instance,
1361 const VkAllocationCallbacks* pAllocator) {
1362 InstanceData& data = GetData(instance);
1363 data.driver.DestroyInstance(instance, pAllocator);
1364
1365 VkAllocationCallbacks local_allocator;
1366 if (!pAllocator) {
1367 local_allocator = data.allocator;
1368 pAllocator = &local_allocator;
1369 }
1370
1371 FreeInstanceData(&data, *pAllocator);
1372 }
1373
CreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)1374 VkResult CreateDevice(VkPhysicalDevice physicalDevice,
1375 const VkDeviceCreateInfo* pCreateInfo,
1376 const VkAllocationCallbacks* pAllocator,
1377 VkDevice* pDevice) {
1378 const InstanceData& instance_data = GetData(physicalDevice);
1379 const VkAllocationCallbacks& data_allocator =
1380 (pAllocator) ? *pAllocator : instance_data.allocator;
1381
1382 VkPhysicalDeviceProperties properties;
1383 ATRACE_BEGIN("driver.GetPhysicalDeviceProperties");
1384 instance_data.driver.GetPhysicalDeviceProperties(physicalDevice,
1385 &properties);
1386 ATRACE_END();
1387
1388 CreateInfoWrapper wrapper(
1389 physicalDevice, *pCreateInfo,
1390 properties.apiVersion ^ VK_API_VERSION_PATCH(properties.apiVersion),
1391 data_allocator);
1392 VkResult result = wrapper.Validate();
1393 if (result != VK_SUCCESS)
1394 return result;
1395
1396 ATRACE_BEGIN("AllocateDeviceData");
1397 DeviceData* data = AllocateDeviceData(data_allocator,
1398 instance_data.debug_report_callbacks);
1399 ATRACE_END();
1400 if (!data)
1401 return VK_ERROR_OUT_OF_HOST_MEMORY;
1402
1403 data->hook_extensions |= wrapper.GetHookExtensions();
1404
1405 // call into the driver
1406 VkDevice dev;
1407 ATRACE_BEGIN("driver.CreateDevice");
1408 result = instance_data.driver.CreateDevice(
1409 physicalDevice, static_cast<const VkDeviceCreateInfo*>(wrapper),
1410 pAllocator, &dev);
1411 ATRACE_END();
1412 if (result != VK_SUCCESS) {
1413 FreeDeviceData(data, data_allocator);
1414 return result;
1415 }
1416
1417 // initialize DeviceDriverTable
1418 if (!SetData(dev, *data) ||
1419 !InitDriverTable(dev, instance_data.get_device_proc_addr,
1420 wrapper.GetHalExtensions())) {
1421 data->driver.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(
1422 instance_data.get_device_proc_addr(dev, "vkDestroyDevice"));
1423 if (data->driver.DestroyDevice)
1424 data->driver.DestroyDevice(dev, pAllocator);
1425
1426 FreeDeviceData(data, data_allocator);
1427
1428 return VK_ERROR_INCOMPATIBLE_DRIVER;
1429 }
1430
1431 // Confirming ANDROID_native_buffer implementation, whose set of
1432 // entrypoints varies according to the spec version.
1433 if ((wrapper.GetHalExtensions()[ProcHook::ANDROID_native_buffer]) &&
1434 !data->driver.GetSwapchainGrallocUsageANDROID &&
1435 !data->driver.GetSwapchainGrallocUsage2ANDROID &&
1436 !data->driver.GetSwapchainGrallocUsage3ANDROID &&
1437 !data->driver.GetSwapchainGrallocUsage4ANDROID) {
1438 ALOGE(
1439 "Driver's implementation of ANDROID_native_buffer is broken;"
1440 " must expose at least one of "
1441 "vkGetSwapchainGrallocUsageANDROID or "
1442 "vkGetSwapchainGrallocUsage2ANDROID or "
1443 "vkGetSwapchainGrallocUsage3ANDROID or "
1444 "vkGetSwapchainGrallocUsage4ANDROID");
1445
1446 data->driver.DestroyDevice(dev, pAllocator);
1447 FreeDeviceData(data, data_allocator);
1448
1449 return VK_ERROR_INCOMPATIBLE_DRIVER;
1450 }
1451
1452 if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) {
1453 // Log that the app is hitting software Vulkan implementation
1454 android::GraphicsEnv::getInstance().setTargetStats(
1455 android::GpuStatsInfo::Stats::CPU_VULKAN_IN_USE);
1456 }
1457
1458 data->driver_device = dev;
1459
1460 *pDevice = dev;
1461
1462 // TODO(b/259516419) avoid getting stats from hwui
1463 const bool reportStats = true;
1464 if (reportStats) {
1465 android::GraphicsEnv::getInstance().setTargetStats(
1466 android::GpuStatsInfo::Stats::CREATED_VULKAN_DEVICE);
1467
1468 // Set stats for creating a Vulkan device and report features in use
1469 const VkPhysicalDeviceFeatures* pEnabledFeatures =
1470 pCreateInfo->pEnabledFeatures;
1471 if (!pEnabledFeatures) {
1472 // Use features from the chained VkPhysicalDeviceFeatures2
1473 // structure, if given
1474 const VkPhysicalDeviceFeatures2* features2 =
1475 reinterpret_cast<const VkPhysicalDeviceFeatures2*>(
1476 pCreateInfo->pNext);
1477 while (features2 &&
1478 features2->sType !=
1479 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) {
1480 features2 = reinterpret_cast<const VkPhysicalDeviceFeatures2*>(
1481 features2->pNext);
1482 }
1483 if (features2) {
1484 pEnabledFeatures = &features2->features;
1485 }
1486 }
1487 const VkBool32* pFeatures =
1488 reinterpret_cast<const VkBool32*>(pEnabledFeatures);
1489 if (pFeatures) {
1490 // VkPhysicalDeviceFeatures consists of VkBool32 values, go over all
1491 // of them using pointer arithmetic here and save the features in a
1492 // 64-bit bitfield
1493 static_assert(
1494 (sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32)) <= 64,
1495 "VkPhysicalDeviceFeatures has too many elements for bitfield "
1496 "packing");
1497 static_assert(
1498 (sizeof(VkPhysicalDeviceFeatures) % sizeof(VkBool32)) == 0,
1499 "VkPhysicalDeviceFeatures has invalid size for bitfield "
1500 "packing");
1501 const int numFeatures =
1502 sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
1503
1504 uint64_t enableFeatureBits = 0;
1505 for (int i = 0; i < numFeatures; i++) {
1506 if (pFeatures[i] != VK_FALSE) {
1507 enableFeatureBits |= (uint64_t(1) << i);
1508 }
1509 }
1510 android::GraphicsEnv::getInstance().setTargetStats(
1511 android::GpuStatsInfo::Stats::VULKAN_DEVICE_FEATURES_ENABLED,
1512 enableFeatureBits);
1513 }
1514
1515 // Update stats for the extensions requested
1516 android::GraphicsEnv::getInstance().setVulkanDeviceExtensions(
1517 pCreateInfo->enabledExtensionCount,
1518 pCreateInfo->ppEnabledExtensionNames);
1519 }
1520
1521 return VK_SUCCESS;
1522 }
1523
DestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)1524 void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
1525 DeviceData& data = GetData(device);
1526 data.driver.DestroyDevice(device, pAllocator);
1527
1528 VkAllocationCallbacks local_allocator;
1529 if (!pAllocator) {
1530 local_allocator = data.allocator;
1531 pAllocator = &local_allocator;
1532 }
1533
1534 FreeDeviceData(&data, *pAllocator);
1535 }
1536
EnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)1537 VkResult EnumeratePhysicalDevices(VkInstance instance,
1538 uint32_t* pPhysicalDeviceCount,
1539 VkPhysicalDevice* pPhysicalDevices) {
1540 ATRACE_CALL();
1541
1542 const auto& data = GetData(instance);
1543
1544 VkResult result = data.driver.EnumeratePhysicalDevices(
1545 instance, pPhysicalDeviceCount, pPhysicalDevices);
1546 if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pPhysicalDevices) {
1547 for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++)
1548 SetData(pPhysicalDevices[i], data);
1549 }
1550
1551 return result;
1552 }
1553
EnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)1554 VkResult EnumeratePhysicalDeviceGroups(
1555 VkInstance instance,
1556 uint32_t* pPhysicalDeviceGroupCount,
1557 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
1558 ATRACE_CALL();
1559
1560 VkResult result = VK_SUCCESS;
1561 const auto& data = GetData(instance);
1562
1563 if (!data.driver.EnumeratePhysicalDeviceGroups &&
1564 !data.driver.EnumeratePhysicalDeviceGroupsKHR) {
1565 uint32_t device_count = 0;
1566 result = EnumeratePhysicalDevices(instance, &device_count, nullptr);
1567 if (result < 0)
1568 return result;
1569
1570 if (!pPhysicalDeviceGroupProperties) {
1571 *pPhysicalDeviceGroupCount = device_count;
1572 return result;
1573 }
1574
1575 if (!device_count) {
1576 *pPhysicalDeviceGroupCount = 0;
1577 return result;
1578 }
1579 device_count = std::min(device_count, *pPhysicalDeviceGroupCount);
1580 if (!device_count)
1581 return VK_INCOMPLETE;
1582
1583 std::vector<VkPhysicalDevice> devices(device_count);
1584 *pPhysicalDeviceGroupCount = device_count;
1585 result =
1586 EnumeratePhysicalDevices(instance, &device_count, devices.data());
1587 if (result < 0)
1588 return result;
1589
1590 for (uint32_t i = 0; i < device_count; ++i) {
1591 pPhysicalDeviceGroupProperties[i].physicalDeviceCount = 1;
1592 pPhysicalDeviceGroupProperties[i].physicalDevices[0] = devices[i];
1593 pPhysicalDeviceGroupProperties[i].subsetAllocation = 0;
1594 }
1595 } else {
1596 if (data.driver.EnumeratePhysicalDeviceGroups) {
1597 result = data.driver.EnumeratePhysicalDeviceGroups(
1598 instance, pPhysicalDeviceGroupCount,
1599 pPhysicalDeviceGroupProperties);
1600 } else {
1601 result = data.driver.EnumeratePhysicalDeviceGroupsKHR(
1602 instance, pPhysicalDeviceGroupCount,
1603 pPhysicalDeviceGroupProperties);
1604 }
1605 if ((result == VK_SUCCESS || result == VK_INCOMPLETE) &&
1606 *pPhysicalDeviceGroupCount && pPhysicalDeviceGroupProperties) {
1607 for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) {
1608 for (uint32_t j = 0;
1609 j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount;
1610 j++) {
1611 SetData(
1612 pPhysicalDeviceGroupProperties[i].physicalDevices[j],
1613 data);
1614 }
1615 }
1616 }
1617 }
1618
1619 return result;
1620 }
1621
GetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)1622 void GetDeviceQueue(VkDevice device,
1623 uint32_t queueFamilyIndex,
1624 uint32_t queueIndex,
1625 VkQueue* pQueue) {
1626 ATRACE_CALL();
1627
1628 const auto& data = GetData(device);
1629
1630 data.driver.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
1631 SetData(*pQueue, data);
1632 }
1633
GetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)1634 void GetDeviceQueue2(VkDevice device,
1635 const VkDeviceQueueInfo2* pQueueInfo,
1636 VkQueue* pQueue) {
1637 ATRACE_CALL();
1638
1639 const auto& data = GetData(device);
1640
1641 data.driver.GetDeviceQueue2(device, pQueueInfo, pQueue);
1642 if (*pQueue != VK_NULL_HANDLE) SetData(*pQueue, data);
1643 }
1644
AllocateCommandBuffers(VkDevice device,const VkCommandBufferAllocateInfo * pAllocateInfo,VkCommandBuffer * pCommandBuffers)1645 VkResult AllocateCommandBuffers(
1646 VkDevice device,
1647 const VkCommandBufferAllocateInfo* pAllocateInfo,
1648 VkCommandBuffer* pCommandBuffers) {
1649 ATRACE_CALL();
1650
1651 const auto& data = GetData(device);
1652
1653 VkResult result = data.driver.AllocateCommandBuffers(device, pAllocateInfo,
1654 pCommandBuffers);
1655 if (result == VK_SUCCESS) {
1656 for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++)
1657 SetData(pCommandBuffers[i], data);
1658 }
1659
1660 return result;
1661 }
1662
QueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence)1663 VkResult QueueSubmit(VkQueue queue,
1664 uint32_t submitCount,
1665 const VkSubmitInfo* pSubmits,
1666 VkFence fence) {
1667 ATRACE_CALL();
1668
1669 const auto& data = GetData(queue);
1670
1671 return data.driver.QueueSubmit(queue, submitCount, pSubmits, fence);
1672 }
1673
GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)1674 void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
1675 VkPhysicalDeviceFeatures2* pFeatures) {
1676 ATRACE_CALL();
1677
1678 const auto& driver = GetData(physicalDevice).driver;
1679
1680 if (driver.GetPhysicalDeviceFeatures2) {
1681 driver.GetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
1682 } else {
1683 driver.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
1684 }
1685
1686 // Conditionally add imageCompressionControlSwapchain if
1687 // imageCompressionControl is supported Check for imageCompressionControl in
1688 // the pChain
1689 bool imageCompressionControl = false;
1690 bool imageCompressionControlInChain = false;
1691 bool imageCompressionControlSwapchainInChain = false;
1692 VkPhysicalDeviceFeatures2* pFeats = pFeatures;
1693 while (pFeats) {
1694 switch (pFeats->sType) {
1695 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
1696 const VkPhysicalDeviceImageCompressionControlFeaturesEXT*
1697 compressionFeat = reinterpret_cast<
1698 const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
1699 pFeats);
1700 imageCompressionControl =
1701 compressionFeat->imageCompressionControl;
1702 imageCompressionControlInChain = true;
1703 } break;
1704
1705 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
1706 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*
1707 compressionFeat = reinterpret_cast<
1708 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
1709 pFeats);
1710 compressionFeat->imageCompressionControlSwapchain = false;
1711 imageCompressionControlSwapchainInChain = true;
1712 } break;
1713
1714 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
1715 auto smf = reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(
1716 pFeats);
1717 smf->swapchainMaintenance1 = true;
1718 } break;
1719
1720 default:
1721 break;
1722 }
1723 pFeats = reinterpret_cast<VkPhysicalDeviceFeatures2*>(pFeats->pNext);
1724 }
1725
1726 if (!imageCompressionControlSwapchainInChain) {
1727 return;
1728 }
1729
1730 // If not in pchain, explicitly query for imageCompressionControl
1731 if (!imageCompressionControlInChain) {
1732 VkPhysicalDeviceImageCompressionControlFeaturesEXT imageCompFeats = {};
1733 imageCompFeats.sType =
1734 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
1735 imageCompFeats.pNext = nullptr;
1736 imageCompFeats.imageCompressionControl = false;
1737
1738 VkPhysicalDeviceFeatures2 feats2 = {};
1739 feats2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1740 feats2.pNext = &imageCompFeats;
1741
1742 if (driver.GetPhysicalDeviceFeatures2) {
1743 driver.GetPhysicalDeviceFeatures2(physicalDevice, &feats2);
1744 } else {
1745 driver.GetPhysicalDeviceFeatures2KHR(physicalDevice, &feats2);
1746 }
1747
1748 imageCompressionControl = imageCompFeats.imageCompressionControl;
1749 }
1750
1751 // Only enumerate imageCompressionControlSwapchin if imageCompressionControl
1752 if (imageCompressionControl) {
1753 pFeats = pFeatures;
1754 while (pFeats) {
1755 switch (pFeats->sType) {
1756 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
1757 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*
1758 compressionFeat = reinterpret_cast<
1759 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
1760 pFeats);
1761 compressionFeat->imageCompressionControlSwapchain = true;
1762 } break;
1763
1764 default:
1765 break;
1766 }
1767 pFeats =
1768 reinterpret_cast<VkPhysicalDeviceFeatures2*>(pFeats->pNext);
1769 }
1770 }
1771 }
1772
GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)1773 void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
1774 VkPhysicalDeviceProperties2* pProperties) {
1775 ATRACE_CALL();
1776
1777 const auto& driver = GetData(physicalDevice).driver;
1778
1779 if (driver.GetPhysicalDeviceProperties2) {
1780 driver.GetPhysicalDeviceProperties2(physicalDevice, pProperties);
1781 return;
1782 }
1783
1784 driver.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
1785 }
1786
GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)1787 void GetPhysicalDeviceFormatProperties2(
1788 VkPhysicalDevice physicalDevice,
1789 VkFormat format,
1790 VkFormatProperties2* pFormatProperties) {
1791 ATRACE_CALL();
1792
1793 const auto& driver = GetData(physicalDevice).driver;
1794
1795 if (driver.GetPhysicalDeviceFormatProperties2) {
1796 driver.GetPhysicalDeviceFormatProperties2(physicalDevice, format,
1797 pFormatProperties);
1798 return;
1799 }
1800
1801 driver.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format,
1802 pFormatProperties);
1803 }
1804
GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)1805 VkResult GetPhysicalDeviceImageFormatProperties2(
1806 VkPhysicalDevice physicalDevice,
1807 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
1808 VkImageFormatProperties2* pImageFormatProperties) {
1809 ATRACE_CALL();
1810
1811 const auto& driver = GetData(physicalDevice).driver;
1812
1813 if (driver.GetPhysicalDeviceImageFormatProperties2) {
1814 return driver.GetPhysicalDeviceImageFormatProperties2(
1815 physicalDevice, pImageFormatInfo, pImageFormatProperties);
1816 }
1817
1818 return driver.GetPhysicalDeviceImageFormatProperties2KHR(
1819 physicalDevice, pImageFormatInfo, pImageFormatProperties);
1820 }
1821
GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)1822 void GetPhysicalDeviceQueueFamilyProperties2(
1823 VkPhysicalDevice physicalDevice,
1824 uint32_t* pQueueFamilyPropertyCount,
1825 VkQueueFamilyProperties2* pQueueFamilyProperties) {
1826 ATRACE_CALL();
1827
1828 const auto& driver = GetData(physicalDevice).driver;
1829
1830 if (driver.GetPhysicalDeviceQueueFamilyProperties2) {
1831 driver.GetPhysicalDeviceQueueFamilyProperties2(
1832 physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1833 return;
1834 }
1835
1836 driver.GetPhysicalDeviceQueueFamilyProperties2KHR(
1837 physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1838 }
1839
GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)1840 void GetPhysicalDeviceMemoryProperties2(
1841 VkPhysicalDevice physicalDevice,
1842 VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
1843 ATRACE_CALL();
1844
1845 const auto& driver = GetData(physicalDevice).driver;
1846
1847 if (driver.GetPhysicalDeviceMemoryProperties2) {
1848 driver.GetPhysicalDeviceMemoryProperties2(physicalDevice,
1849 pMemoryProperties);
1850 return;
1851 }
1852
1853 driver.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice,
1854 pMemoryProperties);
1855 }
1856
GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)1857 void GetPhysicalDeviceSparseImageFormatProperties2(
1858 VkPhysicalDevice physicalDevice,
1859 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1860 uint32_t* pPropertyCount,
1861 VkSparseImageFormatProperties2* pProperties) {
1862 ATRACE_CALL();
1863
1864 const auto& driver = GetData(physicalDevice).driver;
1865
1866 if (driver.GetPhysicalDeviceSparseImageFormatProperties2) {
1867 driver.GetPhysicalDeviceSparseImageFormatProperties2(
1868 physicalDevice, pFormatInfo, pPropertyCount, pProperties);
1869 return;
1870 }
1871
1872 driver.GetPhysicalDeviceSparseImageFormatProperties2KHR(
1873 physicalDevice, pFormatInfo, pPropertyCount, pProperties);
1874 }
1875
GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)1876 void GetPhysicalDeviceExternalBufferProperties(
1877 VkPhysicalDevice physicalDevice,
1878 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
1879 VkExternalBufferProperties* pExternalBufferProperties) {
1880 ATRACE_CALL();
1881
1882 const auto& driver = GetData(physicalDevice).driver;
1883
1884 if (driver.GetPhysicalDeviceExternalBufferProperties) {
1885 driver.GetPhysicalDeviceExternalBufferProperties(
1886 physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
1887 return;
1888 }
1889
1890 if (driver.GetPhysicalDeviceExternalBufferPropertiesKHR) {
1891 driver.GetPhysicalDeviceExternalBufferPropertiesKHR(
1892 physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
1893 return;
1894 }
1895
1896 memset(&pExternalBufferProperties->externalMemoryProperties, 0,
1897 sizeof(VkExternalMemoryProperties));
1898 }
1899
GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)1900 void GetPhysicalDeviceExternalSemaphoreProperties(
1901 VkPhysicalDevice physicalDevice,
1902 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1903 VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
1904 ATRACE_CALL();
1905
1906 const auto& driver = GetData(physicalDevice).driver;
1907
1908 if (driver.GetPhysicalDeviceExternalSemaphoreProperties) {
1909 driver.GetPhysicalDeviceExternalSemaphoreProperties(
1910 physicalDevice, pExternalSemaphoreInfo,
1911 pExternalSemaphoreProperties);
1912 return;
1913 }
1914
1915 if (driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR) {
1916 driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR(
1917 physicalDevice, pExternalSemaphoreInfo,
1918 pExternalSemaphoreProperties);
1919 return;
1920 }
1921
1922 pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
1923 pExternalSemaphoreProperties->compatibleHandleTypes = 0;
1924 pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
1925 }
1926
GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)1927 void GetPhysicalDeviceExternalFenceProperties(
1928 VkPhysicalDevice physicalDevice,
1929 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
1930 VkExternalFenceProperties* pExternalFenceProperties) {
1931 ATRACE_CALL();
1932
1933 const auto& driver = GetData(physicalDevice).driver;
1934
1935 if (driver.GetPhysicalDeviceExternalFenceProperties) {
1936 driver.GetPhysicalDeviceExternalFenceProperties(
1937 physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
1938 return;
1939 }
1940
1941 if (driver.GetPhysicalDeviceExternalFencePropertiesKHR) {
1942 driver.GetPhysicalDeviceExternalFencePropertiesKHR(
1943 physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
1944 return;
1945 }
1946
1947 pExternalFenceProperties->exportFromImportedHandleTypes = 0;
1948 pExternalFenceProperties->compatibleHandleTypes = 0;
1949 pExternalFenceProperties->externalFenceFeatures = 0;
1950 }
1951
1952 } // namespace driver
1953 } // namespace vulkan
1954