api.cpp revision 6184b20d8e2301ecc21f815e1f9c2676c43878d1
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// The API layer of the loader defines Vulkan API and manages layers.  The
18// entrypoints are generated and defined in api_dispatch.cpp.  Most of them
19// simply find the dispatch table and jump.
20//
21// There are a few of them requiring manual code for things such as layer
22// discovery or chaining.  They call into functions defined in this file.
23
24#include <stdlib.h>
25#include <string.h>
26#include <algorithm>
27#include <mutex>
28#include <new>
29#include <utility>
30#include <cutils/properties.h>
31#include <log/log.h>
32
33#include <vulkan/vk_layer_interface.h>
34#include "api.h"
35#include "driver.h"
36#include "layers_extensions.h"
37
38namespace vulkan {
39namespace api {
40
41namespace {
42
43// Provide overridden layer names when there are implicit layers.  No effect
44// otherwise.
45class OverrideLayerNames {
46   public:
47    OverrideLayerNames(bool is_instance, const VkAllocationCallbacks& allocator)
48        : is_instance_(is_instance),
49          allocator_(allocator),
50          scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
51          names_(nullptr),
52          name_count_(0),
53          implicit_layers_() {
54        implicit_layers_.result = VK_SUCCESS;
55    }
56
57    ~OverrideLayerNames() {
58        allocator_.pfnFree(allocator_.pUserData, names_);
59        allocator_.pfnFree(allocator_.pUserData, implicit_layers_.elements);
60        allocator_.pfnFree(allocator_.pUserData, implicit_layers_.name_pool);
61    }
62
63    VkResult Parse(const char* const* names, uint32_t count) {
64        AddImplicitLayers();
65
66        const auto& arr = implicit_layers_;
67        if (arr.result != VK_SUCCESS)
68            return arr.result;
69
70        // no need to override when there is no implicit layer
71        if (!arr.count)
72            return VK_SUCCESS;
73
74        names_ = AllocateNameArray(arr.count + count);
75        if (!names_)
76            return VK_ERROR_OUT_OF_HOST_MEMORY;
77
78        // add implicit layer names
79        for (uint32_t i = 0; i < arr.count; i++)
80            names_[i] = GetImplicitLayerName(i);
81
82        name_count_ = arr.count;
83
84        // add explicit layer names
85        for (uint32_t i = 0; i < count; i++) {
86            // ignore explicit layers that are also implicit
87            if (IsImplicitLayer(names[i]))
88                continue;
89
90            names_[name_count_++] = names[i];
91        }
92
93        return VK_SUCCESS;
94    }
95
96    const char* const* Names() const { return names_; }
97
98    uint32_t Count() const { return name_count_; }
99
100   private:
101    struct ImplicitLayer {
102        int priority;
103        size_t name_offset;
104    };
105
106    struct ImplicitLayerArray {
107        ImplicitLayer* elements;
108        uint32_t max_count;
109        uint32_t count;
110
111        char* name_pool;
112        size_t max_pool_size;
113        size_t pool_size;
114
115        VkResult result;
116    };
117
118    void AddImplicitLayers() {
119        if (!driver::Debuggable())
120            return;
121
122        ParseDebugVulkanLayers();
123        property_list(ParseDebugVulkanLayer, this);
124
125        // sort by priorities
126        auto& arr = implicit_layers_;
127        std::sort(arr.elements, arr.elements + arr.count,
128                  [](const ImplicitLayer& a, const ImplicitLayer& b) {
129                      return (a.priority < b.priority);
130                  });
131    }
132
133    void ParseDebugVulkanLayers() {
134        // debug.vulkan.layers specifies colon-separated layer names
135        char prop[PROPERTY_VALUE_MAX];
136        if (!property_get("debug.vulkan.layers", prop, ""))
137            return;
138
139        // assign negative/high priorities to them
140        int prio = -PROPERTY_VALUE_MAX;
141
142        const char* p = prop;
143        const char* delim;
144        while ((delim = strchr(p, ':'))) {
145            if (delim > p)
146                AddImplicitLayer(prio, p, static_cast<size_t>(delim - p));
147
148            prio++;
149            p = delim + 1;
150        }
151
152        if (p[0] != '\0')
153            AddImplicitLayer(prio, p, strlen(p));
154    }
155
156    static void ParseDebugVulkanLayer(const char* key,
157                                      const char* val,
158                                      void* user_data) {
159        static const char prefix[] = "debug.vulkan.layer.";
160        const size_t prefix_len = sizeof(prefix) - 1;
161
162        if (strncmp(key, prefix, prefix_len) || val[0] == '\0')
163            return;
164        key += prefix_len;
165
166        // debug.vulkan.layer.<priority>
167        int priority = -1;
168        if (key[0] >= '0' && key[0] <= '9')
169            priority = atoi(key);
170
171        if (priority < 0) {
172            ALOGW("Ignored implicit layer %s with invalid priority %s", val,
173                  key);
174            return;
175        }
176
177        OverrideLayerNames& override_layers =
178            *reinterpret_cast<OverrideLayerNames*>(user_data);
179        override_layers.AddImplicitLayer(priority, val, strlen(val));
180    }
181
182    void AddImplicitLayer(int priority, const char* name, size_t len) {
183        if (!GrowImplicitLayerArray(1, 0))
184            return;
185
186        auto& arr = implicit_layers_;
187        auto& layer = arr.elements[arr.count++];
188
189        layer.priority = priority;
190        layer.name_offset = AddImplicitLayerName(name, len);
191
192        ALOGV("Added implicit layer %s", GetImplicitLayerName(arr.count - 1));
193    }
194
195    size_t AddImplicitLayerName(const char* name, size_t len) {
196        if (!GrowImplicitLayerArray(0, len + 1))
197            return 0;
198
199        // add the name to the pool
200        auto& arr = implicit_layers_;
201        size_t offset = arr.pool_size;
202        char* dst = arr.name_pool + offset;
203
204        std::copy(name, name + len, dst);
205        dst[len] = '\0';
206
207        arr.pool_size += len + 1;
208
209        return offset;
210    }
211
212    bool GrowImplicitLayerArray(uint32_t layer_count, size_t name_size) {
213        const uint32_t initial_max_count = 16;
214        const size_t initial_max_pool_size = 512;
215
216        auto& arr = implicit_layers_;
217
218        // grow the element array if needed
219        while (arr.count + layer_count > arr.max_count) {
220            uint32_t new_max_count =
221                (arr.max_count) ? (arr.max_count << 1) : initial_max_count;
222            void* new_mem = nullptr;
223
224            if (new_max_count > arr.max_count) {
225                new_mem = allocator_.pfnReallocation(
226                    allocator_.pUserData, arr.elements,
227                    sizeof(ImplicitLayer) * new_max_count,
228                    alignof(ImplicitLayer), scope_);
229            }
230
231            if (!new_mem) {
232                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
233                arr.count = 0;
234                return false;
235            }
236
237            arr.elements = reinterpret_cast<ImplicitLayer*>(new_mem);
238            arr.max_count = new_max_count;
239        }
240
241        // grow the name pool if needed
242        while (arr.pool_size + name_size > arr.max_pool_size) {
243            size_t new_max_pool_size = (arr.max_pool_size)
244                                           ? (arr.max_pool_size << 1)
245                                           : initial_max_pool_size;
246            void* new_mem = nullptr;
247
248            if (new_max_pool_size > arr.max_pool_size) {
249                new_mem = allocator_.pfnReallocation(
250                    allocator_.pUserData, arr.name_pool, new_max_pool_size,
251                    alignof(char), scope_);
252            }
253
254            if (!new_mem) {
255                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
256                arr.pool_size = 0;
257                return false;
258            }
259
260            arr.name_pool = reinterpret_cast<char*>(new_mem);
261            arr.max_pool_size = new_max_pool_size;
262        }
263
264        return true;
265    }
266
267    const char* GetImplicitLayerName(uint32_t index) const {
268        const auto& arr = implicit_layers_;
269
270        // this may return nullptr when arr.result is not VK_SUCCESS
271        return implicit_layers_.name_pool + arr.elements[index].name_offset;
272    }
273
274    bool IsImplicitLayer(const char* name) const {
275        const auto& arr = implicit_layers_;
276
277        for (uint32_t i = 0; i < arr.count; i++) {
278            if (strcmp(name, GetImplicitLayerName(i)) == 0)
279                return true;
280        }
281
282        return false;
283    }
284
285    const char** AllocateNameArray(uint32_t count) const {
286        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
287            allocator_.pUserData, sizeof(const char*) * count,
288            alignof(const char*), scope_));
289    }
290
291    const bool is_instance_;
292    const VkAllocationCallbacks& allocator_;
293    const VkSystemAllocationScope scope_;
294
295    const char** names_;
296    uint32_t name_count_;
297
298    ImplicitLayerArray implicit_layers_;
299};
300
301// Provide overridden extension names when there are implicit extensions.
302// No effect otherwise.
303//
304// This is used only to enable VK_EXT_debug_report.
305class OverrideExtensionNames {
306   public:
307    OverrideExtensionNames(bool is_instance,
308                           const VkAllocationCallbacks& allocator)
309        : is_instance_(is_instance),
310          allocator_(allocator),
311          scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
312          names_(nullptr),
313          name_count_(0),
314          install_debug_callback_(false) {}
315
316    ~OverrideExtensionNames() {
317        allocator_.pfnFree(allocator_.pUserData, names_);
318    }
319
320    VkResult Parse(const char* const* names, uint32_t count) {
321        // this is only for debug.vulkan.enable_callback
322        if (!EnableDebugCallback())
323            return VK_SUCCESS;
324
325        names_ = AllocateNameArray(count + 1);
326        if (!names_)
327            return VK_ERROR_OUT_OF_HOST_MEMORY;
328
329        std::copy(names, names + count, names_);
330
331        name_count_ = count;
332        names_[name_count_++] = "VK_EXT_debug_report";
333
334        install_debug_callback_ = true;
335
336        return VK_SUCCESS;
337    }
338
339    const char* const* Names() const { return names_; }
340
341    uint32_t Count() const { return name_count_; }
342
343    bool InstallDebugCallback() const { return install_debug_callback_; }
344
345   private:
346    bool EnableDebugCallback() const {
347        return (is_instance_ && driver::Debuggable() &&
348                property_get_bool("debug.vulkan.enable_callback", false));
349    }
350
351    const char** AllocateNameArray(uint32_t count) const {
352        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
353            allocator_.pUserData, sizeof(const char*) * count,
354            alignof(const char*), scope_));
355    }
356
357    const bool is_instance_;
358    const VkAllocationCallbacks& allocator_;
359    const VkSystemAllocationScope scope_;
360
361    const char** names_;
362    uint32_t name_count_;
363    bool install_debug_callback_;
364};
365
366// vkCreateInstance and vkCreateDevice helpers with support for layer
367// chaining.
368class LayerChain {
369   public:
370    static VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
371                                   const VkAllocationCallbacks* allocator,
372                                   VkInstance* instance_out);
373
374    static VkResult CreateDevice(VkPhysicalDevice physical_dev,
375                                 const VkDeviceCreateInfo* create_info,
376                                 const VkAllocationCallbacks* allocator,
377                                 VkDevice* dev_out);
378
379    static void DestroyInstance(VkInstance instance,
380                                const VkAllocationCallbacks* allocator);
381
382    static void DestroyDevice(VkDevice dev,
383                              const VkAllocationCallbacks* allocator);
384
385   private:
386    struct ActiveLayer {
387        LayerRef ref;
388        union {
389            VkLayerInstanceLink instance_link;
390            VkLayerDeviceLink device_link;
391        };
392    };
393
394    LayerChain(bool is_instance, const VkAllocationCallbacks& allocator);
395    ~LayerChain();
396
397    VkResult ActivateLayers(const char* const* layer_names,
398                            uint32_t layer_count,
399                            const char* const* extension_names,
400                            uint32_t extension_count);
401    ActiveLayer* AllocateLayerArray(uint32_t count) const;
402    VkResult LoadLayer(ActiveLayer& layer, const char* name);
403    void SetupLayerLinks();
404
405    bool Empty() const;
406    void ModifyCreateInfo(VkInstanceCreateInfo& info);
407    void ModifyCreateInfo(VkDeviceCreateInfo& info);
408
409    VkResult Create(const VkInstanceCreateInfo* create_info,
410                    const VkAllocationCallbacks* allocator,
411                    VkInstance* instance_out);
412
413    VkResult Create(VkPhysicalDevice physical_dev,
414                    const VkDeviceCreateInfo* create_info,
415                    const VkAllocationCallbacks* allocator,
416                    VkDevice* dev_out);
417
418    VkResult ValidateExtensions(const char* const* extension_names,
419                                uint32_t extension_count);
420    VkResult ValidateExtensions(VkPhysicalDevice physical_dev,
421                                const char* const* extension_names,
422                                uint32_t extension_count);
423    VkExtensionProperties* AllocateDriverExtensionArray(uint32_t count) const;
424    bool IsLayerExtension(const char* name) const;
425    bool IsDriverExtension(const char* name) const;
426
427    template <typename DataType>
428    void StealLayers(DataType& data);
429
430    static void DestroyLayers(ActiveLayer* layers,
431                              uint32_t count,
432                              const VkAllocationCallbacks& allocator);
433
434    static VKAPI_ATTR VkResult SetInstanceLoaderData(VkInstance instance,
435                                                     void* object);
436    static VKAPI_ATTR VkResult SetDeviceLoaderData(VkDevice device,
437                                                   void* object);
438
439    static VKAPI_ATTR VkBool32
440    DebugReportCallback(VkDebugReportFlagsEXT flags,
441                        VkDebugReportObjectTypeEXT obj_type,
442                        uint64_t obj,
443                        size_t location,
444                        int32_t msg_code,
445                        const char* layer_prefix,
446                        const char* msg,
447                        void* user_data);
448
449    const bool is_instance_;
450    const VkAllocationCallbacks& allocator_;
451
452    OverrideLayerNames override_layers_;
453    OverrideExtensionNames override_extensions_;
454
455    ActiveLayer* layers_;
456    uint32_t layer_count_;
457
458    PFN_vkGetInstanceProcAddr get_instance_proc_addr_;
459    PFN_vkGetDeviceProcAddr get_device_proc_addr_;
460
461    union {
462        VkLayerInstanceCreateInfo instance_chain_info_[2];
463        VkLayerDeviceCreateInfo device_chain_info_[2];
464    };
465
466    VkExtensionProperties* driver_extensions_;
467    uint32_t driver_extension_count_;
468    std::bitset<driver::ProcHook::EXTENSION_COUNT> enabled_extensions_;
469};
470
471LayerChain::LayerChain(bool is_instance, const VkAllocationCallbacks& allocator)
472    : is_instance_(is_instance),
473      allocator_(allocator),
474      override_layers_(is_instance, allocator),
475      override_extensions_(is_instance, allocator),
476      layers_(nullptr),
477      layer_count_(0),
478      get_instance_proc_addr_(nullptr),
479      get_device_proc_addr_(nullptr),
480      driver_extensions_(nullptr),
481      driver_extension_count_(0) {
482    enabled_extensions_.set(driver::ProcHook::EXTENSION_CORE);
483}
484
485LayerChain::~LayerChain() {
486    allocator_.pfnFree(allocator_.pUserData, driver_extensions_);
487    DestroyLayers(layers_, layer_count_, allocator_);
488}
489
490VkResult LayerChain::ActivateLayers(const char* const* layer_names,
491                                    uint32_t layer_count,
492                                    const char* const* extension_names,
493                                    uint32_t extension_count) {
494    VkResult result = override_layers_.Parse(layer_names, layer_count);
495    if (result != VK_SUCCESS)
496        return result;
497
498    result = override_extensions_.Parse(extension_names, extension_count);
499    if (result != VK_SUCCESS)
500        return result;
501
502    if (override_layers_.Count()) {
503        layer_names = override_layers_.Names();
504        layer_count = override_layers_.Count();
505    }
506
507    if (!layer_count) {
508        // point head of chain to the driver
509        get_instance_proc_addr_ = driver::GetInstanceProcAddr;
510        if (!is_instance_)
511            get_device_proc_addr_ = driver::GetDeviceProcAddr;
512
513        return VK_SUCCESS;
514    }
515
516    layers_ = AllocateLayerArray(layer_count);
517    if (!layers_)
518        return VK_ERROR_OUT_OF_HOST_MEMORY;
519
520    // load layers
521    for (uint32_t i = 0; i < layer_count; i++) {
522        result = LoadLayer(layers_[i], layer_names[i]);
523        if (result != VK_SUCCESS)
524            return result;
525
526        // count loaded layers for proper destructions on errors
527        layer_count_++;
528    }
529
530    SetupLayerLinks();
531
532    return VK_SUCCESS;
533}
534
535LayerChain::ActiveLayer* LayerChain::AllocateLayerArray(uint32_t count) const {
536    VkSystemAllocationScope scope = (is_instance_)
537                                        ? VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
538                                        : VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
539
540    return reinterpret_cast<ActiveLayer*>(allocator_.pfnAllocation(
541        allocator_.pUserData, sizeof(ActiveLayer) * count, alignof(ActiveLayer),
542        scope));
543}
544
545VkResult LayerChain::LoadLayer(ActiveLayer& layer, const char* name) {
546    const Layer* l = FindLayer(name);
547    if (!l || (!is_instance_ && !IsLayerGlobal(*l))) {
548        ALOGW("Failed to find layer %s", name);
549        return VK_ERROR_LAYER_NOT_PRESENT;
550    }
551
552    new (&layer) ActiveLayer{GetLayerRef(*l), {}};
553    if (!layer.ref) {
554        ALOGW("Failed to open layer %s", name);
555        layer.ref.~LayerRef();
556        return VK_ERROR_LAYER_NOT_PRESENT;
557    }
558
559    ALOGI("Loaded %s layer %s", (is_instance_) ? "instance" : "device", name);
560
561    return VK_SUCCESS;
562}
563
564void LayerChain::SetupLayerLinks() {
565    if (is_instance_) {
566        for (uint32_t i = 0; i < layer_count_; i++) {
567            ActiveLayer& layer = layers_[i];
568
569            // point head of chain to the first layer
570            if (i == 0)
571                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
572
573            // point tail of chain to the driver
574            if (i == layer_count_ - 1) {
575                layer.instance_link.pNext = nullptr;
576                layer.instance_link.pfnNextGetInstanceProcAddr =
577                    driver::GetInstanceProcAddr;
578                break;
579            }
580
581            const ActiveLayer& next = layers_[i + 1];
582
583            // const_cast as some naughty layers want to modify our links!
584            layer.instance_link.pNext =
585                const_cast<VkLayerInstanceLink*>(&next.instance_link);
586            layer.instance_link.pfnNextGetInstanceProcAddr =
587                next.ref.GetGetInstanceProcAddr();
588        }
589    } else {
590        for (uint32_t i = 0; i < layer_count_; i++) {
591            ActiveLayer& layer = layers_[i];
592
593            // point head of chain to the first layer
594            if (i == 0) {
595                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
596                get_device_proc_addr_ = layer.ref.GetGetDeviceProcAddr();
597            }
598
599            // point tail of chain to the driver
600            if (i == layer_count_ - 1) {
601                layer.device_link.pNext = nullptr;
602                layer.device_link.pfnNextGetInstanceProcAddr =
603                    driver::GetInstanceProcAddr;
604                layer.device_link.pfnNextGetDeviceProcAddr =
605                    driver::GetDeviceProcAddr;
606                break;
607            }
608
609            const ActiveLayer& next = layers_[i + 1];
610
611            // const_cast as some naughty layers want to modify our links!
612            layer.device_link.pNext =
613                const_cast<VkLayerDeviceLink*>(&next.device_link);
614            layer.device_link.pfnNextGetInstanceProcAddr =
615                next.ref.GetGetInstanceProcAddr();
616            layer.device_link.pfnNextGetDeviceProcAddr =
617                next.ref.GetGetDeviceProcAddr();
618        }
619    }
620}
621
622bool LayerChain::Empty() const {
623    return (!layer_count_ && !override_layers_.Count() &&
624            !override_extensions_.Count());
625}
626
627void LayerChain::ModifyCreateInfo(VkInstanceCreateInfo& info) {
628    if (layer_count_) {
629        auto& link_info = instance_chain_info_[1];
630        link_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
631        link_info.pNext = info.pNext;
632        link_info.function = VK_LAYER_FUNCTION_LINK;
633        link_info.u.pLayerInfo = &layers_[0].instance_link;
634
635        auto& cb_info = instance_chain_info_[0];
636        cb_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
637        cb_info.pNext = &link_info;
638        cb_info.function = VK_LAYER_FUNCTION_DATA_CALLBACK;
639        cb_info.u.pfnSetInstanceLoaderData = SetInstanceLoaderData;
640
641        info.pNext = &cb_info;
642    }
643
644    if (override_layers_.Count()) {
645        info.enabledLayerCount = override_layers_.Count();
646        info.ppEnabledLayerNames = override_layers_.Names();
647    }
648
649    if (override_extensions_.Count()) {
650        info.enabledExtensionCount = override_extensions_.Count();
651        info.ppEnabledExtensionNames = override_extensions_.Names();
652    }
653}
654
655void LayerChain::ModifyCreateInfo(VkDeviceCreateInfo& info) {
656    if (layer_count_) {
657        auto& link_info = device_chain_info_[1];
658        link_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
659        link_info.pNext = info.pNext;
660        link_info.function = VK_LAYER_FUNCTION_LINK;
661        link_info.u.pLayerInfo = &layers_[0].device_link;
662
663        auto& cb_info = device_chain_info_[0];
664        cb_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
665        cb_info.pNext = &link_info;
666        cb_info.function = VK_LAYER_FUNCTION_DATA_CALLBACK;
667        cb_info.u.pfnSetDeviceLoaderData = SetDeviceLoaderData;
668
669        info.pNext = &cb_info;
670    }
671
672    if (override_layers_.Count()) {
673        info.enabledLayerCount = override_layers_.Count();
674        info.ppEnabledLayerNames = override_layers_.Names();
675    }
676
677    if (override_extensions_.Count()) {
678        info.enabledExtensionCount = override_extensions_.Count();
679        info.ppEnabledExtensionNames = override_extensions_.Names();
680    }
681}
682
683VkResult LayerChain::Create(const VkInstanceCreateInfo* create_info,
684                            const VkAllocationCallbacks* allocator,
685                            VkInstance* instance_out) {
686    VkResult result = ValidateExtensions(create_info->ppEnabledExtensionNames,
687                                         create_info->enabledExtensionCount);
688    if (result != VK_SUCCESS)
689        return result;
690
691    // call down the chain
692    PFN_vkCreateInstance create_instance =
693        reinterpret_cast<PFN_vkCreateInstance>(
694            get_instance_proc_addr_(VK_NULL_HANDLE, "vkCreateInstance"));
695    VkInstance instance;
696    result = create_instance(create_info, allocator, &instance);
697    if (result != VK_SUCCESS)
698        return result;
699
700    // initialize InstanceData
701    InstanceData& data = GetData(instance);
702
703    data.instance = instance;
704
705    if (!InitDispatchTable(instance, get_instance_proc_addr_,
706                           enabled_extensions_)) {
707        if (data.dispatch.DestroyInstance)
708            data.dispatch.DestroyInstance(instance, allocator);
709
710        return VK_ERROR_INITIALIZATION_FAILED;
711    }
712
713    // install debug report callback
714    if (override_extensions_.InstallDebugCallback()) {
715        PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
716            reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
717                get_instance_proc_addr_(instance,
718                                        "vkCreateDebugReportCallbackEXT"));
719        data.destroy_debug_callback =
720            reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
721                get_instance_proc_addr_(instance,
722                                        "vkDestroyDebugReportCallbackEXT"));
723        if (!create_debug_report_callback || !data.destroy_debug_callback) {
724            ALOGE("Broken VK_EXT_debug_report support");
725            data.dispatch.DestroyInstance(instance, allocator);
726            return VK_ERROR_INITIALIZATION_FAILED;
727        }
728
729        VkDebugReportCallbackCreateInfoEXT debug_callback_info = {};
730        debug_callback_info.sType =
731            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
732        debug_callback_info.flags =
733            VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
734        debug_callback_info.pfnCallback = DebugReportCallback;
735
736        VkDebugReportCallbackEXT debug_callback;
737        result = create_debug_report_callback(instance, &debug_callback_info,
738                                              nullptr, &debug_callback);
739        if (result != VK_SUCCESS) {
740            ALOGE("Failed to install debug report callback");
741            data.dispatch.DestroyInstance(instance, allocator);
742            return VK_ERROR_INITIALIZATION_FAILED;
743        }
744
745        data.debug_callback = debug_callback;
746
747        ALOGI("Installed debug report callback");
748    }
749
750    StealLayers(data);
751
752    *instance_out = instance;
753
754    return VK_SUCCESS;
755}
756
757VkResult LayerChain::Create(VkPhysicalDevice physical_dev,
758                            const VkDeviceCreateInfo* create_info,
759                            const VkAllocationCallbacks* allocator,
760                            VkDevice* dev_out) {
761    VkResult result =
762        ValidateExtensions(physical_dev, create_info->ppEnabledExtensionNames,
763                           create_info->enabledExtensionCount);
764    if (result != VK_SUCCESS)
765        return result;
766
767    // call down the chain
768    //
769    // TODO Instance call chain available at
770    // GetData(physical_dev).dispatch.CreateDevice is ignored.  Is that
771    // right?
772    VkInstance instance = GetData(physical_dev).instance;
773    PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
774        get_instance_proc_addr_(instance, "vkCreateDevice"));
775    VkDevice dev;
776    result = create_device(physical_dev, create_info, allocator, &dev);
777    if (result != VK_SUCCESS)
778        return result;
779
780    // initialize DeviceData
781    DeviceData& data = GetData(dev);
782
783    if (!InitDispatchTable(dev, get_device_proc_addr_, enabled_extensions_)) {
784        if (data.dispatch.DestroyDevice)
785            data.dispatch.DestroyDevice(dev, allocator);
786
787        return VK_ERROR_INITIALIZATION_FAILED;
788    }
789
790    StealLayers(data);
791
792    *dev_out = dev;
793
794    return VK_SUCCESS;
795}
796
797VkResult LayerChain::ValidateExtensions(const char* const* extension_names,
798                                        uint32_t extension_count) {
799    if (!extension_count)
800        return VK_SUCCESS;
801
802    // query driver instance extensions
803    uint32_t count;
804    VkResult result =
805        EnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
806    if (result == VK_SUCCESS && count) {
807        driver_extensions_ = AllocateDriverExtensionArray(count);
808        result = (driver_extensions_) ? EnumerateInstanceExtensionProperties(
809                                            nullptr, &count, driver_extensions_)
810                                      : VK_ERROR_OUT_OF_HOST_MEMORY;
811    }
812    if (result != VK_SUCCESS)
813        return result;
814
815    driver_extension_count_ = count;
816
817    for (uint32_t i = 0; i < extension_count; i++) {
818        const char* name = extension_names[i];
819        if (!IsLayerExtension(name) && !IsDriverExtension(name)) {
820            ALOGE("Failed to enable missing instance extension %s", name);
821            return VK_ERROR_EXTENSION_NOT_PRESENT;
822        }
823
824        auto ext_bit = driver::GetProcHookExtension(name);
825        if (ext_bit != driver::ProcHook::EXTENSION_UNKNOWN)
826            enabled_extensions_.set(ext_bit);
827    }
828
829    return VK_SUCCESS;
830}
831
832VkResult LayerChain::ValidateExtensions(VkPhysicalDevice physical_dev,
833                                        const char* const* extension_names,
834                                        uint32_t extension_count) {
835    if (!extension_count)
836        return VK_SUCCESS;
837
838    // query driver device extensions
839    uint32_t count;
840    VkResult result = EnumerateDeviceExtensionProperties(physical_dev, nullptr,
841                                                         &count, nullptr);
842    if (result == VK_SUCCESS && count) {
843        driver_extensions_ = AllocateDriverExtensionArray(count);
844        result = (driver_extensions_)
845                     ? EnumerateDeviceExtensionProperties(
846                           physical_dev, nullptr, &count, driver_extensions_)
847                     : VK_ERROR_OUT_OF_HOST_MEMORY;
848    }
849    if (result != VK_SUCCESS)
850        return result;
851
852    driver_extension_count_ = count;
853
854    for (uint32_t i = 0; i < extension_count; i++) {
855        const char* name = extension_names[i];
856        if (!IsLayerExtension(name) && !IsDriverExtension(name)) {
857            ALOGE("Failed to enable missing device extension %s", name);
858            return VK_ERROR_EXTENSION_NOT_PRESENT;
859        }
860
861        auto ext_bit = driver::GetProcHookExtension(name);
862        if (ext_bit != driver::ProcHook::EXTENSION_UNKNOWN)
863            enabled_extensions_.set(ext_bit);
864    }
865
866    return VK_SUCCESS;
867}
868
869VkExtensionProperties* LayerChain::AllocateDriverExtensionArray(
870    uint32_t count) const {
871    return reinterpret_cast<VkExtensionProperties*>(allocator_.pfnAllocation(
872        allocator_.pUserData, sizeof(VkExtensionProperties) * count,
873        alignof(VkExtensionProperties), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
874}
875
876bool LayerChain::IsLayerExtension(const char* name) const {
877    if (is_instance_) {
878        for (uint32_t i = 0; i < layer_count_; i++) {
879            const ActiveLayer& layer = layers_[i];
880            if (FindLayerInstanceExtension(*layer.ref, name))
881                return true;
882        }
883    } else {
884        for (uint32_t i = 0; i < layer_count_; i++) {
885            const ActiveLayer& layer = layers_[i];
886            if (FindLayerDeviceExtension(*layer.ref, name))
887                return true;
888        }
889    }
890
891    return false;
892}
893
894bool LayerChain::IsDriverExtension(const char* name) const {
895    for (uint32_t i = 0; i < driver_extension_count_; i++) {
896        if (strcmp(driver_extensions_[i].extensionName, name) == 0)
897            return true;
898    }
899
900    return false;
901}
902
903template <typename DataType>
904void LayerChain::StealLayers(DataType& data) {
905    data.layers = layers_;
906    data.layer_count = layer_count_;
907
908    layers_ = nullptr;
909    layer_count_ = 0;
910}
911
912void LayerChain::DestroyLayers(ActiveLayer* layers,
913                               uint32_t count,
914                               const VkAllocationCallbacks& allocator) {
915    for (uint32_t i = 0; i < count; i++)
916        layers[i].ref.~LayerRef();
917
918    allocator.pfnFree(allocator.pUserData, layers);
919}
920
921VkResult LayerChain::SetInstanceLoaderData(VkInstance instance, void* object) {
922    driver::InstanceDispatchable dispatchable =
923        reinterpret_cast<driver::InstanceDispatchable>(object);
924
925    return (driver::SetDataInternal(dispatchable, &driver::GetData(instance)))
926               ? VK_SUCCESS
927               : VK_ERROR_INITIALIZATION_FAILED;
928}
929
930VkResult LayerChain::SetDeviceLoaderData(VkDevice device, void* object) {
931    driver::DeviceDispatchable dispatchable =
932        reinterpret_cast<driver::DeviceDispatchable>(object);
933
934    return (driver::SetDataInternal(dispatchable, &driver::GetData(device)))
935               ? VK_SUCCESS
936               : VK_ERROR_INITIALIZATION_FAILED;
937}
938
939VkBool32 LayerChain::DebugReportCallback(VkDebugReportFlagsEXT flags,
940                                         VkDebugReportObjectTypeEXT obj_type,
941                                         uint64_t obj,
942                                         size_t location,
943                                         int32_t msg_code,
944                                         const char* layer_prefix,
945                                         const char* msg,
946                                         void* user_data) {
947    int prio;
948
949    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
950        prio = ANDROID_LOG_ERROR;
951    else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT |
952                      VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
953        prio = ANDROID_LOG_WARN;
954    else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
955        prio = ANDROID_LOG_INFO;
956    else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
957        prio = ANDROID_LOG_DEBUG;
958    else
959        prio = ANDROID_LOG_UNKNOWN;
960
961    LOG_PRI(prio, LOG_TAG, "[%s] Code %d : %s", layer_prefix, msg_code, msg);
962
963    (void)obj_type;
964    (void)obj;
965    (void)location;
966    (void)user_data;
967
968    return false;
969}
970
971VkResult LayerChain::CreateInstance(const VkInstanceCreateInfo* create_info,
972                                    const VkAllocationCallbacks* allocator,
973                                    VkInstance* instance_out) {
974    LayerChain chain(true,
975                     (allocator) ? *allocator : driver::GetDefaultAllocator());
976
977    VkResult result = chain.ActivateLayers(create_info->ppEnabledLayerNames,
978                                           create_info->enabledLayerCount,
979                                           create_info->ppEnabledExtensionNames,
980                                           create_info->enabledExtensionCount);
981    if (result != VK_SUCCESS)
982        return result;
983
984    // use a local create info when the chain is not empty
985    VkInstanceCreateInfo local_create_info;
986    if (!chain.Empty()) {
987        local_create_info = *create_info;
988        chain.ModifyCreateInfo(local_create_info);
989        create_info = &local_create_info;
990    }
991
992    return chain.Create(create_info, allocator, instance_out);
993}
994
995VkResult LayerChain::CreateDevice(VkPhysicalDevice physical_dev,
996                                  const VkDeviceCreateInfo* create_info,
997                                  const VkAllocationCallbacks* allocator,
998                                  VkDevice* dev_out) {
999    LayerChain chain(false, (allocator)
1000                                ? *allocator
1001                                : driver::GetData(physical_dev).allocator);
1002
1003    VkResult result = chain.ActivateLayers(create_info->ppEnabledLayerNames,
1004                                           create_info->enabledLayerCount,
1005                                           create_info->ppEnabledExtensionNames,
1006                                           create_info->enabledExtensionCount);
1007    if (result != VK_SUCCESS)
1008        return result;
1009
1010    // use a local create info when the chain is not empty
1011    VkDeviceCreateInfo local_create_info;
1012    if (!chain.Empty()) {
1013        local_create_info = *create_info;
1014        chain.ModifyCreateInfo(local_create_info);
1015        create_info = &local_create_info;
1016    }
1017
1018    return chain.Create(physical_dev, create_info, allocator, dev_out);
1019}
1020
1021void LayerChain::DestroyInstance(VkInstance instance,
1022                                 const VkAllocationCallbacks* allocator) {
1023    InstanceData& data = GetData(instance);
1024
1025    if (data.debug_callback != VK_NULL_HANDLE)
1026        data.destroy_debug_callback(instance, data.debug_callback, allocator);
1027
1028    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
1029    uint32_t layer_count = data.layer_count;
1030
1031    VkAllocationCallbacks local_allocator;
1032    if (!allocator)
1033        local_allocator = driver::GetData(instance).allocator;
1034
1035    // this also destroys InstanceData
1036    data.dispatch.DestroyInstance(instance, allocator);
1037
1038    DestroyLayers(layers, layer_count,
1039                  (allocator) ? *allocator : local_allocator);
1040}
1041
1042void LayerChain::DestroyDevice(VkDevice device,
1043                               const VkAllocationCallbacks* allocator) {
1044    DeviceData& data = GetData(device);
1045
1046    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
1047    uint32_t layer_count = data.layer_count;
1048
1049    VkAllocationCallbacks local_allocator;
1050    if (!allocator)
1051        local_allocator = driver::GetData(device).allocator;
1052
1053    // this also destroys DeviceData
1054    data.dispatch.DestroyDevice(device, allocator);
1055
1056    DestroyLayers(layers, layer_count,
1057                  (allocator) ? *allocator : local_allocator);
1058}
1059
1060// ----------------------------------------------------------------------------
1061
1062bool EnsureInitialized() {
1063    static std::once_flag once_flag;
1064    static bool initialized;
1065
1066    std::call_once(once_flag, []() {
1067        if (driver::OpenHAL()) {
1068            DiscoverLayers();
1069            initialized = true;
1070        }
1071    });
1072
1073    return initialized;
1074}
1075
1076}  // anonymous namespace
1077
1078VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
1079                        const VkAllocationCallbacks* pAllocator,
1080                        VkInstance* pInstance) {
1081    if (!EnsureInitialized())
1082        return VK_ERROR_INITIALIZATION_FAILED;
1083
1084    return LayerChain::CreateInstance(pCreateInfo, pAllocator, pInstance);
1085}
1086
1087void DestroyInstance(VkInstance instance,
1088                     const VkAllocationCallbacks* pAllocator) {
1089    if (instance != VK_NULL_HANDLE)
1090        LayerChain::DestroyInstance(instance, pAllocator);
1091}
1092
1093VkResult CreateDevice(VkPhysicalDevice physicalDevice,
1094                      const VkDeviceCreateInfo* pCreateInfo,
1095                      const VkAllocationCallbacks* pAllocator,
1096                      VkDevice* pDevice) {
1097    return LayerChain::CreateDevice(physicalDevice, pCreateInfo, pAllocator,
1098                                    pDevice);
1099}
1100
1101void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
1102    if (device != VK_NULL_HANDLE)
1103        LayerChain::DestroyDevice(device, pAllocator);
1104}
1105
1106VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
1107                                          VkLayerProperties* pProperties) {
1108    if (!EnsureInitialized())
1109        return VK_ERROR_INITIALIZATION_FAILED;
1110
1111    uint32_t count = GetLayerCount();
1112
1113    if (!pProperties) {
1114        *pPropertyCount = count;
1115        return VK_SUCCESS;
1116    }
1117
1118    uint32_t copied = std::min(*pPropertyCount, count);
1119    for (uint32_t i = 0; i < copied; i++)
1120        pProperties[i] = GetLayerProperties(GetLayer(i));
1121    *pPropertyCount = copied;
1122
1123    return (copied == count) ? VK_SUCCESS : VK_INCOMPLETE;
1124}
1125
1126VkResult EnumerateInstanceExtensionProperties(
1127    const char* pLayerName,
1128    uint32_t* pPropertyCount,
1129    VkExtensionProperties* pProperties) {
1130    if (!EnsureInitialized())
1131        return VK_ERROR_INITIALIZATION_FAILED;
1132
1133    if (pLayerName) {
1134        const Layer* layer = FindLayer(pLayerName);
1135        if (!layer)
1136            return VK_ERROR_LAYER_NOT_PRESENT;
1137
1138        uint32_t count;
1139        const VkExtensionProperties* props =
1140            GetLayerInstanceExtensions(*layer, count);
1141
1142        if (!pProperties || *pPropertyCount > count)
1143            *pPropertyCount = count;
1144        if (pProperties)
1145            std::copy(props, props + *pPropertyCount, pProperties);
1146
1147        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1148    }
1149
1150    // TODO how about extensions from implicitly enabled layers?
1151    return vulkan::driver::EnumerateInstanceExtensionProperties(
1152        nullptr, pPropertyCount, pProperties);
1153}
1154
1155VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
1156                                        uint32_t* pPropertyCount,
1157                                        VkLayerProperties* pProperties) {
1158    (void)physicalDevice;
1159
1160    uint32_t total_count = GetLayerCount();
1161
1162    if (!pProperties) {
1163        uint32_t count = 0;
1164        for (uint32_t i = 0; i < total_count; i++) {
1165            if (IsLayerGlobal(GetLayer(i)))
1166                count++;
1167        }
1168
1169        *pPropertyCount = count;
1170        return VK_SUCCESS;
1171    }
1172
1173    uint32_t count = 0;
1174    uint32_t copied = 0;
1175    for (uint32_t i = 0; i < total_count; i++) {
1176        const Layer& layer = GetLayer(i);
1177        if (!IsLayerGlobal(layer))
1178            continue;
1179
1180        count++;
1181        if (copied < *pPropertyCount)
1182            pProperties[copied++] = GetLayerProperties(layer);
1183    }
1184
1185    *pPropertyCount = copied;
1186
1187    return (copied == count) ? VK_SUCCESS : VK_INCOMPLETE;
1188}
1189
1190VkResult EnumerateDeviceExtensionProperties(
1191    VkPhysicalDevice physicalDevice,
1192    const char* pLayerName,
1193    uint32_t* pPropertyCount,
1194    VkExtensionProperties* pProperties) {
1195    if (pLayerName) {
1196        const Layer* layer = FindLayer(pLayerName);
1197        if (!layer || !IsLayerGlobal(*layer))
1198            return VK_ERROR_LAYER_NOT_PRESENT;
1199
1200        uint32_t count;
1201        const VkExtensionProperties* props =
1202            GetLayerDeviceExtensions(*layer, count);
1203
1204        if (!pProperties || *pPropertyCount > count)
1205            *pPropertyCount = count;
1206        if (pProperties)
1207            std::copy(props, props + *pPropertyCount, pProperties);
1208
1209        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1210    }
1211
1212    // TODO how about extensions from implicitly enabled layers?
1213    const InstanceData& data = GetData(physicalDevice);
1214    return data.dispatch.EnumerateDeviceExtensionProperties(
1215        physicalDevice, nullptr, pPropertyCount, pProperties);
1216}
1217
1218}  // namespace api
1219}  // namespace vulkan
1220