api.cpp revision 4ad5c1414b3cfcbe5b3c3b9f21b42f23d99bafba
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        add_implicit_layers();
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_ = allocate_name_array(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] = get_implicit_layer_name(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 (is_implicit_layer(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 add_implicit_layers() {
119        if (!driver::Debuggable())
120            return;
121
122        parse_debug_vulkan_layers();
123        property_list(parse_debug_vulkan_layer, 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 parse_debug_vulkan_layers() {
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                add_implicit_layer(prio, p, static_cast<size_t>(delim - p));
147
148            prio++;
149            p = delim + 1;
150        }
151
152        if (p[0] != '\0')
153            add_implicit_layer(prio, p, strlen(p));
154    }
155
156    static void parse_debug_vulkan_layer(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.add_implicit_layer(priority, val, strlen(val));
180    }
181
182    void add_implicit_layer(int priority, const char* name, size_t len) {
183        if (!grow_implicit_layer_array(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 = add_implicit_layer_name(name, len);
191
192        ALOGV("Added implicit layer %s",
193              get_implicit_layer_name(arr.count - 1));
194    }
195
196    size_t add_implicit_layer_name(const char* name, size_t len) {
197        if (!grow_implicit_layer_array(0, len + 1))
198            return 0;
199
200        // add the name to the pool
201        auto& arr = implicit_layers_;
202        size_t offset = arr.pool_size;
203        char* dst = arr.name_pool + offset;
204
205        std::copy(name, name + len, dst);
206        dst[len] = '\0';
207
208        arr.pool_size += len + 1;
209
210        return offset;
211    }
212
213    bool grow_implicit_layer_array(uint32_t layer_count, size_t name_size) {
214        const uint32_t initial_max_count = 16;
215        const size_t initial_max_pool_size = 512;
216
217        auto& arr = implicit_layers_;
218
219        // grow the element array if needed
220        while (arr.count + layer_count > arr.max_count) {
221            uint32_t new_max_count =
222                (arr.max_count) ? (arr.max_count << 1) : initial_max_count;
223            void* new_mem = nullptr;
224
225            if (new_max_count > arr.max_count) {
226                new_mem = allocator_.pfnReallocation(
227                    allocator_.pUserData, arr.elements,
228                    sizeof(ImplicitLayer) * new_max_count,
229                    alignof(ImplicitLayer), scope_);
230            }
231
232            if (!new_mem) {
233                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
234                arr.count = 0;
235                return false;
236            }
237
238            arr.elements = reinterpret_cast<ImplicitLayer*>(new_mem);
239            arr.max_count = new_max_count;
240        }
241
242        // grow the name pool if needed
243        while (arr.pool_size + name_size > arr.max_pool_size) {
244            size_t new_max_pool_size = (arr.max_pool_size)
245                                           ? (arr.max_pool_size << 1)
246                                           : initial_max_pool_size;
247            void* new_mem = nullptr;
248
249            if (new_max_pool_size > arr.max_pool_size) {
250                new_mem = allocator_.pfnReallocation(
251                    allocator_.pUserData, arr.name_pool, new_max_pool_size,
252                    alignof(char), scope_);
253            }
254
255            if (!new_mem) {
256                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
257                arr.pool_size = 0;
258                return false;
259            }
260
261            arr.name_pool = reinterpret_cast<char*>(new_mem);
262            arr.max_pool_size = new_max_pool_size;
263        }
264
265        return true;
266    }
267
268    const char* get_implicit_layer_name(uint32_t index) const {
269        const auto& arr = implicit_layers_;
270
271        // this may return nullptr when arr.result is not VK_SUCCESS
272        return implicit_layers_.name_pool + arr.elements[index].name_offset;
273    }
274
275    bool is_implicit_layer(const char* name) const {
276        const auto& arr = implicit_layers_;
277
278        for (uint32_t i = 0; i < arr.count; i++) {
279            if (strcmp(name, get_implicit_layer_name(i)) == 0)
280                return true;
281        }
282
283        return false;
284    }
285
286    const char** allocate_name_array(uint32_t count) const {
287        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
288            allocator_.pUserData, sizeof(const char*) * count,
289            alignof(const char*), scope_));
290    }
291
292    const bool is_instance_;
293    const VkAllocationCallbacks& allocator_;
294    const VkSystemAllocationScope scope_;
295
296    const char** names_;
297    uint32_t name_count_;
298
299    ImplicitLayerArray implicit_layers_;
300};
301
302// Provide overridden extension names when there are implicit extensions.
303// No effect otherwise.
304//
305// This is used only to enable VK_EXT_debug_report.
306class OverrideExtensionNames {
307   public:
308    OverrideExtensionNames(bool is_instance,
309                           const VkAllocationCallbacks& allocator)
310        : is_instance_(is_instance),
311          allocator_(allocator),
312          scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
313          names_(nullptr),
314          name_count_(0),
315          install_debug_callback_(false) {}
316
317    ~OverrideExtensionNames() {
318        allocator_.pfnFree(allocator_.pUserData, names_);
319    }
320
321    VkResult parse(const char* const* names, uint32_t count) {
322        // this is only for debug.vulkan.enable_callback
323        if (!enable_debug_callback())
324            return VK_SUCCESS;
325
326        names_ = allocate_name_array(count + 1);
327        if (!names_)
328            return VK_ERROR_OUT_OF_HOST_MEMORY;
329
330        std::copy(names, names + count, names_);
331
332        name_count_ = count;
333        names_[name_count_++] = "VK_EXT_debug_report";
334
335        install_debug_callback_ = true;
336
337        return VK_SUCCESS;
338    }
339
340    const char* const* names() const { return names_; }
341
342    uint32_t count() const { return name_count_; }
343
344    bool install_debug_callback() const { return install_debug_callback_; }
345
346   private:
347    bool enable_debug_callback() const {
348        return (is_instance_ && driver::Debuggable() &&
349                property_get_bool("debug.vulkan.enable_callback", false));
350    }
351
352    const char** allocate_name_array(uint32_t count) const {
353        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
354            allocator_.pUserData, sizeof(const char*) * count,
355            alignof(const char*), scope_));
356    }
357
358    const bool is_instance_;
359    const VkAllocationCallbacks& allocator_;
360    const VkSystemAllocationScope scope_;
361
362    const char** names_;
363    uint32_t name_count_;
364    bool install_debug_callback_;
365};
366
367// vkCreateInstance and vkCreateDevice helpers with support for layer
368// chaining.
369class LayerChain {
370   public:
371    static VkResult create_instance(const VkInstanceCreateInfo* create_info,
372                                    const VkAllocationCallbacks* allocator,
373                                    VkInstance* instance_out);
374
375    static VkResult create_device(VkPhysicalDevice physical_dev,
376                                  const VkDeviceCreateInfo* create_info,
377                                  const VkAllocationCallbacks* allocator,
378                                  VkDevice* dev_out);
379
380    static void destroy_instance(VkInstance instance,
381                                 const VkAllocationCallbacks* allocator);
382
383    static void destroy_device(VkDevice dev,
384                               const VkAllocationCallbacks* allocator);
385
386   private:
387    struct ActiveLayer {
388        LayerRef ref;
389        union {
390            VkLayerInstanceLink instance_link;
391            VkLayerDeviceLink device_link;
392        };
393    };
394
395    LayerChain(bool is_instance, const VkAllocationCallbacks& allocator);
396    ~LayerChain();
397
398    VkResult activate_layers(const char* const* layer_names,
399                             uint32_t layer_count,
400                             const char* const* extension_names,
401                             uint32_t extension_count);
402    ActiveLayer* allocate_layer_array(uint32_t count) const;
403    VkResult load_layer(ActiveLayer& layer, const char* name);
404    void setup_layer_links();
405
406    bool empty() const;
407    void modify_create_info(VkInstanceCreateInfo& info);
408    void modify_create_info(VkDeviceCreateInfo& info);
409
410    VkResult create(const VkInstanceCreateInfo* create_info,
411                    const VkAllocationCallbacks* allocator,
412                    VkInstance* instance_out);
413
414    VkResult create(VkPhysicalDevice physical_dev,
415                    const VkDeviceCreateInfo* create_info,
416                    const VkAllocationCallbacks* allocator,
417                    VkDevice* dev_out);
418
419    VkResult validate_extensions(const char* const* extension_names,
420                                 uint32_t extension_count);
421    VkResult validate_extensions(VkPhysicalDevice physical_dev,
422                                 const char* const* extension_names,
423                                 uint32_t extension_count);
424    VkExtensionProperties* allocate_driver_extension_array(
425        uint32_t count) const;
426    bool is_layer_extension(const char* name) const;
427    bool is_driver_extension(const char* name) const;
428
429    template <typename DataType>
430    void steal_layers(DataType& data);
431
432    static void destroy_layers(ActiveLayer* layers,
433                               uint32_t count,
434                               const VkAllocationCallbacks& allocator);
435
436    static VKAPI_ATTR VkBool32
437    debug_report_callback(VkDebugReportFlagsEXT flags,
438                          VkDebugReportObjectTypeEXT obj_type,
439                          uint64_t obj,
440                          size_t location,
441                          int32_t msg_code,
442                          const char* layer_prefix,
443                          const char* msg,
444                          void* user_data);
445
446    const bool is_instance_;
447    const VkAllocationCallbacks& allocator_;
448
449    OverrideLayerNames override_layers_;
450    OverrideExtensionNames override_extensions_;
451
452    ActiveLayer* layers_;
453    uint32_t layer_count_;
454
455    PFN_vkGetInstanceProcAddr get_instance_proc_addr_;
456    PFN_vkGetDeviceProcAddr get_device_proc_addr_;
457
458    union {
459        VkLayerInstanceCreateInfo instance_chain_info_;
460        VkLayerDeviceCreateInfo device_chain_info_;
461    };
462
463    VkExtensionProperties* driver_extensions_;
464    uint32_t driver_extension_count_;
465};
466
467LayerChain::LayerChain(bool is_instance, const VkAllocationCallbacks& allocator)
468    : is_instance_(is_instance),
469      allocator_(allocator),
470      override_layers_(is_instance, allocator),
471      override_extensions_(is_instance, allocator),
472      layers_(nullptr),
473      layer_count_(0),
474      get_instance_proc_addr_(nullptr),
475      get_device_proc_addr_(nullptr),
476      driver_extensions_(nullptr),
477      driver_extension_count_(0) {}
478
479LayerChain::~LayerChain() {
480    allocator_.pfnFree(allocator_.pUserData, driver_extensions_);
481    destroy_layers(layers_, layer_count_, allocator_);
482}
483
484VkResult LayerChain::activate_layers(const char* const* layer_names,
485                                     uint32_t layer_count,
486                                     const char* const* extension_names,
487                                     uint32_t extension_count) {
488    VkResult result = override_layers_.parse(layer_names, layer_count);
489    if (result != VK_SUCCESS)
490        return result;
491
492    result = override_extensions_.parse(extension_names, extension_count);
493    if (result != VK_SUCCESS)
494        return result;
495
496    if (override_layers_.count()) {
497        layer_names = override_layers_.names();
498        layer_count = override_layers_.count();
499    }
500
501    if (!layer_count) {
502        // point head of chain to the driver
503        get_instance_proc_addr_ = driver::GetInstanceProcAddr;
504        if (!is_instance_)
505            get_device_proc_addr_ = driver::GetDeviceProcAddr;
506
507        return VK_SUCCESS;
508    }
509
510    layers_ = allocate_layer_array(layer_count);
511    if (!layers_)
512        return VK_ERROR_OUT_OF_HOST_MEMORY;
513
514    // load layers
515    for (uint32_t i = 0; i < layer_count; i++) {
516        result = load_layer(layers_[i], layer_names[i]);
517        if (result != VK_SUCCESS)
518            return result;
519
520        // count loaded layers for proper destructions on errors
521        layer_count_++;
522    }
523
524    setup_layer_links();
525
526    return VK_SUCCESS;
527}
528
529LayerChain::ActiveLayer* LayerChain::allocate_layer_array(
530    uint32_t count) const {
531    VkSystemAllocationScope scope = (is_instance_)
532                                        ? VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
533                                        : VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
534
535    return reinterpret_cast<ActiveLayer*>(allocator_.pfnAllocation(
536        allocator_.pUserData, sizeof(ActiveLayer) * count, alignof(ActiveLayer),
537        scope));
538}
539
540VkResult LayerChain::load_layer(ActiveLayer& layer, const char* name) {
541    if (is_instance_)
542        new (&layer) ActiveLayer{GetInstanceLayerRef(name), {}};
543    else
544        new (&layer) ActiveLayer{GetDeviceLayerRef(name), {}};
545
546    if (!layer.ref) {
547        ALOGE("Failed to load layer %s", name);
548        layer.ref.~LayerRef();
549        return VK_ERROR_LAYER_NOT_PRESENT;
550    }
551
552    ALOGI("Loaded %s layer %s", (is_instance_) ? "instance" : "device", name);
553
554    return VK_SUCCESS;
555}
556
557void LayerChain::setup_layer_links() {
558    if (is_instance_) {
559        for (uint32_t i = 0; i < layer_count_; i++) {
560            ActiveLayer& layer = layers_[i];
561
562            // point head of chain to the first layer
563            if (i == 0)
564                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
565
566            // point tail of chain to the driver
567            if (i == layer_count_ - 1) {
568                layer.instance_link.pNext = nullptr;
569                layer.instance_link.pfnNextGetInstanceProcAddr =
570                    driver::GetInstanceProcAddr;
571                break;
572            }
573
574            const ActiveLayer& next = layers_[i + 1];
575
576            // const_cast as some naughty layers want to modify our links!
577            layer.instance_link.pNext =
578                const_cast<VkLayerInstanceLink*>(&next.instance_link);
579            layer.instance_link.pfnNextGetInstanceProcAddr =
580                next.ref.GetGetInstanceProcAddr();
581        }
582    } else {
583        for (uint32_t i = 0; i < layer_count_; i++) {
584            ActiveLayer& layer = layers_[i];
585
586            // point head of chain to the first layer
587            if (i == 0) {
588                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
589                get_device_proc_addr_ = layer.ref.GetGetDeviceProcAddr();
590            }
591
592            // point tail of chain to the driver
593            if (i == layer_count_ - 1) {
594                layer.device_link.pNext = nullptr;
595                layer.device_link.pfnNextGetInstanceProcAddr =
596                    driver::GetInstanceProcAddr;
597                layer.device_link.pfnNextGetDeviceProcAddr =
598                    driver::GetDeviceProcAddr;
599                break;
600            }
601
602            const ActiveLayer& next = layers_[i + 1];
603
604            // const_cast as some naughty layers want to modify our links!
605            layer.device_link.pNext =
606                const_cast<VkLayerDeviceLink*>(&next.device_link);
607            layer.device_link.pfnNextGetInstanceProcAddr =
608                next.ref.GetGetInstanceProcAddr();
609            layer.device_link.pfnNextGetDeviceProcAddr =
610                next.ref.GetGetDeviceProcAddr();
611        }
612    }
613}
614
615bool LayerChain::empty() const {
616    return (!layer_count_ && !override_layers_.count() &&
617            !override_extensions_.count());
618}
619
620void LayerChain::modify_create_info(VkInstanceCreateInfo& info) {
621    if (layer_count_) {
622        const ActiveLayer& layer = layers_[0];
623
624        instance_chain_info_.sType =
625            VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
626        instance_chain_info_.function = VK_LAYER_FUNCTION_LINK;
627        // TODO fix vk_layer_interface.h and get rid of const_cast?
628        instance_chain_info_.u.pLayerInfo =
629            const_cast<VkLayerInstanceLink*>(&layer.instance_link);
630
631        // insert layer info
632        instance_chain_info_.pNext = info.pNext;
633        info.pNext = &instance_chain_info_;
634    }
635
636    if (override_layers_.count()) {
637        info.enabledLayerCount = override_layers_.count();
638        info.ppEnabledLayerNames = override_layers_.names();
639    }
640
641    if (override_extensions_.count()) {
642        info.enabledExtensionCount = override_extensions_.count();
643        info.ppEnabledExtensionNames = override_extensions_.names();
644    }
645}
646
647void LayerChain::modify_create_info(VkDeviceCreateInfo& info) {
648    if (layer_count_) {
649        const ActiveLayer& layer = layers_[0];
650
651        device_chain_info_.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
652        device_chain_info_.function = VK_LAYER_FUNCTION_LINK;
653        // TODO fix vk_layer_interface.h and get rid of const_cast?
654        device_chain_info_.u.pLayerInfo =
655            const_cast<VkLayerDeviceLink*>(&layer.device_link);
656
657        // insert layer info
658        device_chain_info_.pNext = info.pNext;
659        info.pNext = &device_chain_info_;
660    }
661
662    if (override_layers_.count()) {
663        info.enabledLayerCount = override_layers_.count();
664        info.ppEnabledLayerNames = override_layers_.names();
665    }
666
667    if (override_extensions_.count()) {
668        info.enabledExtensionCount = override_extensions_.count();
669        info.ppEnabledExtensionNames = override_extensions_.names();
670    }
671}
672
673VkResult LayerChain::create(const VkInstanceCreateInfo* create_info,
674                            const VkAllocationCallbacks* allocator,
675                            VkInstance* instance_out) {
676    VkResult result = validate_extensions(create_info->ppEnabledExtensionNames,
677                                          create_info->enabledExtensionCount);
678    if (result != VK_SUCCESS)
679        return result;
680
681    // call down the chain
682    PFN_vkCreateInstance create_instance =
683        reinterpret_cast<PFN_vkCreateInstance>(
684            get_instance_proc_addr_(VK_NULL_HANDLE, "vkCreateInstance"));
685    VkInstance instance;
686    result = create_instance(create_info, allocator, &instance);
687    if (result != VK_SUCCESS)
688        return result;
689
690    // initialize InstanceData
691    InstanceData& data = GetData(instance);
692    memset(&data, 0, sizeof(data));
693
694    data.instance = instance;
695
696    if (!InitDispatchTable(instance, get_instance_proc_addr_)) {
697        if (data.dispatch.DestroyInstance)
698            data.dispatch.DestroyInstance(instance, allocator);
699
700        return VK_ERROR_INITIALIZATION_FAILED;
701    }
702
703    // install debug report callback
704    if (override_extensions_.install_debug_callback()) {
705        PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
706            reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
707                get_instance_proc_addr_(instance,
708                                        "vkCreateDebugReportCallbackEXT"));
709        data.destroy_debug_callback =
710            reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
711                get_instance_proc_addr_(instance,
712                                        "vkDestroyDebugReportCallbackEXT"));
713        if (!create_debug_report_callback || !data.destroy_debug_callback) {
714            ALOGE("Broken VK_EXT_debug_report support");
715            data.dispatch.DestroyInstance(instance, allocator);
716            return VK_ERROR_INITIALIZATION_FAILED;
717        }
718
719        VkDebugReportCallbackCreateInfoEXT debug_callback_info = {};
720        debug_callback_info.sType =
721            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
722        debug_callback_info.flags =
723            VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
724        debug_callback_info.pfnCallback = debug_report_callback;
725
726        VkDebugReportCallbackEXT debug_callback;
727        result = create_debug_report_callback(instance, &debug_callback_info,
728                                              nullptr, &debug_callback);
729        if (result != VK_SUCCESS) {
730            ALOGE("Failed to install debug report callback");
731            data.dispatch.DestroyInstance(instance, allocator);
732            return VK_ERROR_INITIALIZATION_FAILED;
733        }
734
735        data.debug_callback = debug_callback;
736
737        ALOGI("Installed debug report callback");
738    }
739
740    steal_layers(data);
741
742    *instance_out = instance;
743
744    return VK_SUCCESS;
745}
746
747VkResult LayerChain::create(VkPhysicalDevice physical_dev,
748                            const VkDeviceCreateInfo* create_info,
749                            const VkAllocationCallbacks* allocator,
750                            VkDevice* dev_out) {
751    VkResult result =
752        validate_extensions(physical_dev, create_info->ppEnabledExtensionNames,
753                            create_info->enabledExtensionCount);
754    if (result != VK_SUCCESS)
755        return result;
756
757    // call down the chain
758    //
759    // TODO Instance call chain available at
760    // GetData(physical_dev).dispatch.CreateDevice is ignored.  Is that
761    // right?
762    VkInstance instance = GetData(physical_dev).instance;
763    PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
764        get_instance_proc_addr_(instance, "vkCreateDevice"));
765    VkDevice dev;
766    result = create_device(physical_dev, create_info, allocator, &dev);
767    if (result != VK_SUCCESS)
768        return result;
769
770    // initialize DeviceData
771    DeviceData& data = GetData(dev);
772    memset(&data, 0, sizeof(data));
773
774    if (!InitDispatchTable(dev, get_device_proc_addr_)) {
775        if (data.dispatch.DestroyDevice)
776            data.dispatch.DestroyDevice(dev, allocator);
777
778        return VK_ERROR_INITIALIZATION_FAILED;
779    }
780
781    steal_layers(data);
782
783    *dev_out = dev;
784
785    return VK_SUCCESS;
786}
787
788VkResult LayerChain::validate_extensions(const char* const* extension_names,
789                                         uint32_t extension_count) {
790    if (!extension_count)
791        return VK_SUCCESS;
792
793    // query driver instance extensions
794    uint32_t count;
795    VkResult result =
796        EnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
797    if (result == VK_SUCCESS && count) {
798        driver_extensions_ = allocate_driver_extension_array(count);
799        result = (driver_extensions_) ? EnumerateInstanceExtensionProperties(
800                                            nullptr, &count, driver_extensions_)
801                                      : VK_ERROR_OUT_OF_HOST_MEMORY;
802    }
803    if (result != VK_SUCCESS)
804        return result;
805
806    driver_extension_count_ = count;
807
808    for (uint32_t i = 0; i < extension_count; i++) {
809        const char* name = extension_names[i];
810        if (!is_layer_extension(name) && !is_driver_extension(name)) {
811            ALOGE("Failed to enable missing instance extension %s", name);
812            return VK_ERROR_EXTENSION_NOT_PRESENT;
813        }
814    }
815
816    return VK_SUCCESS;
817}
818
819VkResult LayerChain::validate_extensions(VkPhysicalDevice physical_dev,
820                                         const char* const* extension_names,
821                                         uint32_t extension_count) {
822    if (!extension_count)
823        return VK_SUCCESS;
824
825    // query driver device extensions
826    uint32_t count;
827    VkResult result = EnumerateDeviceExtensionProperties(physical_dev, nullptr,
828                                                         &count, nullptr);
829    if (result == VK_SUCCESS && count) {
830        driver_extensions_ = allocate_driver_extension_array(count);
831        result = (driver_extensions_)
832                     ? EnumerateDeviceExtensionProperties(
833                           physical_dev, nullptr, &count, driver_extensions_)
834                     : VK_ERROR_OUT_OF_HOST_MEMORY;
835    }
836    if (result != VK_SUCCESS)
837        return result;
838
839    driver_extension_count_ = count;
840
841    for (uint32_t i = 0; i < extension_count; i++) {
842        const char* name = extension_names[i];
843        if (!is_layer_extension(name) && !is_driver_extension(name)) {
844            ALOGE("Failed to enable missing device extension %s", name);
845            return VK_ERROR_EXTENSION_NOT_PRESENT;
846        }
847    }
848
849    return VK_SUCCESS;
850}
851
852VkExtensionProperties* LayerChain::allocate_driver_extension_array(
853    uint32_t count) const {
854    return reinterpret_cast<VkExtensionProperties*>(allocator_.pfnAllocation(
855        allocator_.pUserData, sizeof(VkExtensionProperties) * count,
856        alignof(VkExtensionProperties), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
857}
858
859bool LayerChain::is_layer_extension(const char* name) const {
860    for (uint32_t i = 0; i < layer_count_; i++) {
861        const ActiveLayer& layer = layers_[i];
862        if (layer.ref.SupportsExtension(name))
863            return true;
864    }
865
866    return false;
867}
868
869bool LayerChain::is_driver_extension(const char* name) const {
870    for (uint32_t i = 0; i < driver_extension_count_; i++) {
871        if (strcmp(driver_extensions_[i].extensionName, name) == 0)
872            return true;
873    }
874
875    return false;
876}
877
878template <typename DataType>
879void LayerChain::steal_layers(DataType& data) {
880    data.layers = layers_;
881    data.layer_count = layer_count_;
882
883    layers_ = nullptr;
884    layer_count_ = 0;
885}
886
887void LayerChain::destroy_layers(ActiveLayer* layers,
888                                uint32_t count,
889                                const VkAllocationCallbacks& allocator) {
890    for (uint32_t i = 0; i < count; i++)
891        layers[i].ref.~LayerRef();
892
893    allocator.pfnFree(allocator.pUserData, layers);
894}
895
896VkBool32 LayerChain::debug_report_callback(VkDebugReportFlagsEXT flags,
897                                           VkDebugReportObjectTypeEXT obj_type,
898                                           uint64_t obj,
899                                           size_t location,
900                                           int32_t msg_code,
901                                           const char* layer_prefix,
902                                           const char* msg,
903                                           void* user_data) {
904    int prio;
905
906    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
907        prio = ANDROID_LOG_ERROR;
908    else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT |
909                      VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
910        prio = ANDROID_LOG_WARN;
911    else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
912        prio = ANDROID_LOG_INFO;
913    else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
914        prio = ANDROID_LOG_DEBUG;
915    else
916        prio = ANDROID_LOG_UNKNOWN;
917
918    LOG_PRI(prio, LOG_TAG, "[%s] Code %d : %s", layer_prefix, msg_code, msg);
919
920    (void)obj_type;
921    (void)obj;
922    (void)location;
923    (void)user_data;
924
925    return false;
926}
927
928VkResult LayerChain::create_instance(const VkInstanceCreateInfo* create_info,
929                                     const VkAllocationCallbacks* allocator,
930                                     VkInstance* instance_out) {
931    LayerChain chain(true,
932                     (allocator) ? *allocator : driver::GetDefaultAllocator());
933
934    VkResult result = chain.activate_layers(
935        create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
936        create_info->ppEnabledExtensionNames,
937        create_info->enabledExtensionCount);
938    if (result != VK_SUCCESS)
939        return result;
940
941    // use a local create info when the chain is not empty
942    VkInstanceCreateInfo local_create_info;
943    if (!chain.empty()) {
944        local_create_info = *create_info;
945        chain.modify_create_info(local_create_info);
946        create_info = &local_create_info;
947    }
948
949    return chain.create(create_info, allocator, instance_out);
950}
951
952VkResult LayerChain::create_device(VkPhysicalDevice physical_dev,
953                                   const VkDeviceCreateInfo* create_info,
954                                   const VkAllocationCallbacks* allocator,
955                                   VkDevice* dev_out) {
956    LayerChain chain(false, (allocator)
957                                ? *allocator
958                                : driver::GetData(physical_dev).allocator);
959
960    VkResult result = chain.activate_layers(
961        create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
962        create_info->ppEnabledExtensionNames,
963        create_info->enabledExtensionCount);
964    if (result != VK_SUCCESS)
965        return result;
966
967    // use a local create info when the chain is not empty
968    VkDeviceCreateInfo local_create_info;
969    if (!chain.empty()) {
970        local_create_info = *create_info;
971        chain.modify_create_info(local_create_info);
972        create_info = &local_create_info;
973    }
974
975    return chain.create(physical_dev, create_info, allocator, dev_out);
976}
977
978void LayerChain::destroy_instance(VkInstance instance,
979                                  const VkAllocationCallbacks* allocator) {
980    InstanceData& data = GetData(instance);
981
982    if (data.debug_callback != VK_NULL_HANDLE)
983        data.destroy_debug_callback(instance, data.debug_callback, allocator);
984
985    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
986    uint32_t layer_count = data.layer_count;
987
988    VkAllocationCallbacks local_allocator;
989    if (!allocator)
990        local_allocator = driver::GetData(instance).allocator;
991
992    // this also destroys InstanceData
993    data.dispatch.DestroyInstance(instance, allocator);
994
995    destroy_layers(layers, layer_count,
996                   (allocator) ? *allocator : local_allocator);
997}
998
999void LayerChain::destroy_device(VkDevice device,
1000                                const VkAllocationCallbacks* allocator) {
1001    DeviceData& data = GetData(device);
1002
1003    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
1004    uint32_t layer_count = data.layer_count;
1005
1006    VkAllocationCallbacks local_allocator;
1007    if (!allocator)
1008        local_allocator = driver::GetData(device).allocator;
1009
1010    // this also destroys DeviceData
1011    data.dispatch.DestroyDevice(device, allocator);
1012
1013    destroy_layers(layers, layer_count,
1014                   (allocator) ? *allocator : local_allocator);
1015}
1016
1017// ----------------------------------------------------------------------------
1018
1019bool EnsureInitialized() {
1020    static std::once_flag once_flag;
1021    static bool initialized;
1022
1023    std::call_once(once_flag, []() {
1024        if (driver::OpenHAL()) {
1025            DiscoverLayers();
1026            initialized = true;
1027        }
1028    });
1029
1030    return initialized;
1031}
1032
1033}  // anonymous namespace
1034
1035VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
1036                        const VkAllocationCallbacks* pAllocator,
1037                        VkInstance* pInstance) {
1038    if (!EnsureInitialized())
1039        return VK_ERROR_INITIALIZATION_FAILED;
1040
1041    return LayerChain::create_instance(pCreateInfo, pAllocator, pInstance);
1042}
1043
1044void DestroyInstance(VkInstance instance,
1045                     const VkAllocationCallbacks* pAllocator) {
1046    if (instance != VK_NULL_HANDLE)
1047        LayerChain::destroy_instance(instance, pAllocator);
1048}
1049
1050VkResult CreateDevice(VkPhysicalDevice physicalDevice,
1051                      const VkDeviceCreateInfo* pCreateInfo,
1052                      const VkAllocationCallbacks* pAllocator,
1053                      VkDevice* pDevice) {
1054    return LayerChain::create_device(physicalDevice, pCreateInfo, pAllocator,
1055                                     pDevice);
1056}
1057
1058void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
1059    if (device != VK_NULL_HANDLE)
1060        LayerChain::destroy_device(device, pAllocator);
1061}
1062
1063VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
1064                                          VkLayerProperties* pProperties) {
1065    if (!EnsureInitialized())
1066        return VK_ERROR_INITIALIZATION_FAILED;
1067
1068    uint32_t count =
1069        EnumerateInstanceLayers(pProperties ? *pPropertyCount : 0, pProperties);
1070
1071    if (!pProperties || *pPropertyCount > count)
1072        *pPropertyCount = count;
1073
1074    return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1075}
1076
1077VkResult EnumerateInstanceExtensionProperties(
1078    const char* pLayerName,
1079    uint32_t* pPropertyCount,
1080    VkExtensionProperties* pProperties) {
1081    if (!EnsureInitialized())
1082        return VK_ERROR_INITIALIZATION_FAILED;
1083
1084    if (pLayerName) {
1085        const VkExtensionProperties* props;
1086        uint32_t count;
1087        GetInstanceLayerExtensions(pLayerName, &props, &count);
1088
1089        if (!pProperties || *pPropertyCount > count)
1090            *pPropertyCount = count;
1091        if (pProperties)
1092            std::copy(props, props + *pPropertyCount, pProperties);
1093
1094        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1095    }
1096
1097    // TODO how about extensions from implicitly enabled layers?
1098    return vulkan::driver::EnumerateInstanceExtensionProperties(
1099        nullptr, pPropertyCount, pProperties);
1100}
1101
1102VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
1103                                        uint32_t* pPropertyCount,
1104                                        VkLayerProperties* pProperties) {
1105    (void)physicalDevice;
1106
1107    uint32_t count =
1108        EnumerateDeviceLayers(pProperties ? *pPropertyCount : 0, pProperties);
1109
1110    if (!pProperties || *pPropertyCount > count)
1111        *pPropertyCount = count;
1112
1113    return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1114}
1115
1116VkResult EnumerateDeviceExtensionProperties(
1117    VkPhysicalDevice physicalDevice,
1118    const char* pLayerName,
1119    uint32_t* pPropertyCount,
1120    VkExtensionProperties* pProperties) {
1121    if (pLayerName) {
1122        const VkExtensionProperties* props;
1123        uint32_t count;
1124        GetDeviceLayerExtensions(pLayerName, &props, &count);
1125
1126        if (!pProperties || *pPropertyCount > count)
1127            *pPropertyCount = count;
1128        if (pProperties)
1129            std::copy(props, props + *pPropertyCount, pProperties);
1130
1131        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1132    }
1133
1134    // TODO how about extensions from implicitly enabled layers?
1135    const InstanceData& data = GetData(physicalDevice);
1136    return data.dispatch.EnumerateDeviceExtensionProperties(
1137        physicalDevice, nullptr, pPropertyCount, pProperties);
1138}
1139
1140}  // namespace api
1141}  // namespace vulkan
1142