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#include "layers_extensions.h"
18
19#include <alloca.h>
20#include <dirent.h>
21#include <dlfcn.h>
22#include <mutex>
23#include <sys/prctl.h>
24#include <string>
25#include <string.h>
26#include <vector>
27
28#include <android-base/strings.h>
29#include <android/dlext.h>
30#include <cutils/properties.h>
31#include <log/log.h>
32#include <ziparchive/zip_archive.h>
33
34#include <vulkan/vulkan_loader_data.h>
35
36// TODO(jessehall): The whole way we deal with extensions is pretty hokey, and
37// not a good long-term solution. Having a hard-coded enum of extensions is
38// bad, of course. Representing sets of extensions (requested, supported, etc.)
39// as a bitset isn't necessarily bad, if the mapping from extension to bit were
40// dynamic. Need to rethink this completely when there's a little more time.
41
42// TODO(jessehall): This file currently builds up global data structures as it
43// loads, and never cleans them up. This means we're doing heap allocations
44// without going through an app-provided allocator, but worse, we'll leak those
45// allocations if the loader is unloaded.
46//
47// We should allocate "enough" BSS space, and suballocate from there. Will
48// probably want to intern strings, etc., and will need some custom/manual data
49// structures.
50
51namespace vulkan {
52namespace api {
53
54struct Layer {
55    VkLayerProperties properties;
56    size_t library_idx;
57
58    // true if the layer intercepts vkCreateDevice and device commands
59    bool is_global;
60
61    std::vector<VkExtensionProperties> instance_extensions;
62    std::vector<VkExtensionProperties> device_extensions;
63};
64
65namespace {
66
67const char kSystemLayerLibraryDir[] = "/data/local/debug/vulkan";
68
69class LayerLibrary {
70   public:
71    LayerLibrary(const std::string& path)
72        : path_(path), dlhandle_(nullptr), refcount_(0) {}
73
74    LayerLibrary(LayerLibrary&& other)
75        : path_(std::move(other.path_)),
76          dlhandle_(other.dlhandle_),
77          refcount_(other.refcount_) {
78        other.dlhandle_ = nullptr;
79        other.refcount_ = 0;
80    }
81
82    LayerLibrary(const LayerLibrary&) = delete;
83    LayerLibrary& operator=(const LayerLibrary&) = delete;
84
85    // these are thread-safe
86    bool Open();
87    void Close();
88
89    bool EnumerateLayers(size_t library_idx,
90                         std::vector<Layer>& instance_layers) const;
91
92    void* GetGPA(const Layer& layer,
93                 const char* gpa_name,
94                 size_t gpa_name_len) const;
95
96   private:
97    const std::string path_;
98
99    std::mutex mutex_;
100    void* dlhandle_;
101    size_t refcount_;
102};
103
104bool LayerLibrary::Open() {
105    std::lock_guard<std::mutex> lock(mutex_);
106    if (refcount_++ == 0) {
107        ALOGV("opening layer library '%s'", path_.c_str());
108        // Libraries in the system layer library dir can't be loaded into
109        // the application namespace. That causes compatibility problems, since
110        // any symbol dependencies will be resolved by system libraries. They
111        // can't safely use libc++_shared, for example. Which is one reason
112        // (among several) we only allow them in non-user builds.
113        auto app_namespace = LoaderData::GetInstance().app_namespace;
114        if (app_namespace &&
115            !android::base::StartsWith(path_, kSystemLayerLibraryDir)) {
116            android_dlextinfo dlextinfo = {};
117            dlextinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
118            dlextinfo.library_namespace = app_namespace;
119            dlhandle_ = android_dlopen_ext(path_.c_str(), RTLD_NOW | RTLD_LOCAL,
120                                           &dlextinfo);
121        } else {
122            dlhandle_ = dlopen(path_.c_str(), RTLD_NOW | RTLD_LOCAL);
123        }
124        if (!dlhandle_) {
125            ALOGE("failed to load layer library '%s': %s", path_.c_str(),
126                  dlerror());
127            refcount_ = 0;
128            return false;
129        }
130    }
131    return true;
132}
133
134void LayerLibrary::Close() {
135    std::lock_guard<std::mutex> lock(mutex_);
136    if (--refcount_ == 0) {
137        ALOGV("closing layer library '%s'", path_.c_str());
138        dlclose(dlhandle_);
139        dlhandle_ = nullptr;
140    }
141}
142
143bool LayerLibrary::EnumerateLayers(size_t library_idx,
144                                   std::vector<Layer>& instance_layers) const {
145    PFN_vkEnumerateInstanceLayerProperties enumerate_instance_layers =
146        reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
147            dlsym(dlhandle_, "vkEnumerateInstanceLayerProperties"));
148    PFN_vkEnumerateInstanceExtensionProperties enumerate_instance_extensions =
149        reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
150            dlsym(dlhandle_, "vkEnumerateInstanceExtensionProperties"));
151    if (!enumerate_instance_layers || !enumerate_instance_extensions) {
152        ALOGE("layer library '%s' missing some instance enumeration functions",
153              path_.c_str());
154        return false;
155    }
156
157    // device functions are optional
158    PFN_vkEnumerateDeviceLayerProperties enumerate_device_layers =
159        reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
160            dlsym(dlhandle_, "vkEnumerateDeviceLayerProperties"));
161    PFN_vkEnumerateDeviceExtensionProperties enumerate_device_extensions =
162        reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
163            dlsym(dlhandle_, "vkEnumerateDeviceExtensionProperties"));
164
165    // get layer counts
166    uint32_t num_instance_layers = 0;
167    uint32_t num_device_layers = 0;
168    VkResult result = enumerate_instance_layers(&num_instance_layers, nullptr);
169    if (result != VK_SUCCESS || !num_instance_layers) {
170        if (result != VK_SUCCESS) {
171            ALOGE(
172                "vkEnumerateInstanceLayerProperties failed for library '%s': "
173                "%d",
174                path_.c_str(), result);
175        }
176        return false;
177    }
178    if (enumerate_device_layers) {
179        result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,
180                                         nullptr);
181        if (result != VK_SUCCESS) {
182            ALOGE(
183                "vkEnumerateDeviceLayerProperties failed for library '%s': %d",
184                path_.c_str(), result);
185            return false;
186        }
187    }
188
189    // get layer properties
190    VkLayerProperties* properties = static_cast<VkLayerProperties*>(alloca(
191        (num_instance_layers + num_device_layers) * sizeof(VkLayerProperties)));
192    result = enumerate_instance_layers(&num_instance_layers, properties);
193    if (result != VK_SUCCESS) {
194        ALOGE("vkEnumerateInstanceLayerProperties failed for library '%s': %d",
195              path_.c_str(), result);
196        return false;
197    }
198    if (num_device_layers > 0) {
199        result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,
200                                         properties + num_instance_layers);
201        if (result != VK_SUCCESS) {
202            ALOGE(
203                "vkEnumerateDeviceLayerProperties failed for library '%s': %d",
204                path_.c_str(), result);
205            return false;
206        }
207    }
208
209    // append layers to instance_layers
210    size_t prev_num_instance_layers = instance_layers.size();
211    instance_layers.reserve(prev_num_instance_layers + num_instance_layers);
212    for (size_t i = 0; i < num_instance_layers; i++) {
213        const VkLayerProperties& props = properties[i];
214
215        Layer layer;
216        layer.properties = props;
217        layer.library_idx = library_idx;
218        layer.is_global = false;
219
220        uint32_t count = 0;
221        result =
222            enumerate_instance_extensions(props.layerName, &count, nullptr);
223        if (result != VK_SUCCESS) {
224            ALOGE(
225                "vkEnumerateInstanceExtensionProperties(\"%s\") failed for "
226                "library '%s': %d",
227                props.layerName, path_.c_str(), result);
228            instance_layers.resize(prev_num_instance_layers);
229            return false;
230        }
231        layer.instance_extensions.resize(count);
232        result = enumerate_instance_extensions(
233            props.layerName, &count, layer.instance_extensions.data());
234        if (result != VK_SUCCESS) {
235            ALOGE(
236                "vkEnumerateInstanceExtensionProperties(\"%s\") failed for "
237                "library '%s': %d",
238                props.layerName, path_.c_str(), result);
239            instance_layers.resize(prev_num_instance_layers);
240            return false;
241        }
242
243        for (size_t j = 0; j < num_device_layers; j++) {
244            const auto& dev_props = properties[num_instance_layers + j];
245            if (memcmp(&props, &dev_props, sizeof(props)) == 0) {
246                layer.is_global = true;
247                break;
248            }
249        }
250
251        if (layer.is_global && enumerate_device_extensions) {
252            result = enumerate_device_extensions(
253                VK_NULL_HANDLE, props.layerName, &count, nullptr);
254            if (result != VK_SUCCESS) {
255                ALOGE(
256                    "vkEnumerateDeviceExtensionProperties(\"%s\") failed for "
257                    "library '%s': %d",
258                    props.layerName, path_.c_str(), result);
259                instance_layers.resize(prev_num_instance_layers);
260                return false;
261            }
262            layer.device_extensions.resize(count);
263            result = enumerate_device_extensions(
264                VK_NULL_HANDLE, props.layerName, &count,
265                layer.device_extensions.data());
266            if (result != VK_SUCCESS) {
267                ALOGE(
268                    "vkEnumerateDeviceExtensionProperties(\"%s\") failed for "
269                    "library '%s': %d",
270                    props.layerName, path_.c_str(), result);
271                instance_layers.resize(prev_num_instance_layers);
272                return false;
273            }
274        }
275
276        instance_layers.push_back(layer);
277        ALOGD("added %s layer '%s' from library '%s'",
278              (layer.is_global) ? "global" : "instance", props.layerName,
279              path_.c_str());
280    }
281
282    return true;
283}
284
285void* LayerLibrary::GetGPA(const Layer& layer,
286                           const char* gpa_name,
287                           size_t gpa_name_len) const {
288    void* gpa;
289    size_t layer_name_len =
290        std::max(size_t{2}, strlen(layer.properties.layerName));
291    char* name = static_cast<char*>(alloca(layer_name_len + gpa_name_len + 1));
292    strcpy(name, layer.properties.layerName);
293    strcpy(name + layer_name_len, gpa_name);
294    if (!(gpa = dlsym(dlhandle_, name))) {
295        strcpy(name, "vk");
296        strcpy(name + 2, gpa_name);
297        gpa = dlsym(dlhandle_, name);
298    }
299    return gpa;
300}
301
302// ----------------------------------------------------------------------------
303
304std::vector<LayerLibrary> g_layer_libraries;
305std::vector<Layer> g_instance_layers;
306
307void AddLayerLibrary(const std::string& path) {
308    LayerLibrary library(path);
309    if (!library.Open())
310        return;
311
312    if (!library.EnumerateLayers(g_layer_libraries.size(), g_instance_layers)) {
313        library.Close();
314        return;
315    }
316
317    library.Close();
318
319    g_layer_libraries.emplace_back(std::move(library));
320}
321
322template <typename Functor>
323void ForEachFileInDir(const std::string& dirname, Functor functor) {
324    auto dir_deleter = [](DIR* handle) { closedir(handle); };
325    std::unique_ptr<DIR, decltype(dir_deleter)> dir(opendir(dirname.c_str()),
326                                                    dir_deleter);
327    if (!dir) {
328        // It's normal for some search directories to not exist, especially
329        // /data/local/debug/vulkan.
330        int err = errno;
331        ALOGW_IF(err != ENOENT, "failed to open layer directory '%s': %s",
332                 dirname.c_str(), strerror(err));
333        return;
334    }
335    ALOGD("searching for layers in '%s'", dirname.c_str());
336    dirent* entry;
337    while ((entry = readdir(dir.get())) != nullptr)
338        functor(entry->d_name);
339}
340
341template <typename Functor>
342void ForEachFileInZip(const std::string& zipname,
343                      const std::string& dir_in_zip,
344                      Functor functor) {
345    int32_t err;
346    ZipArchiveHandle zip = nullptr;
347    if ((err = OpenArchive(zipname.c_str(), &zip)) != 0) {
348        ALOGE("failed to open apk '%s': %d", zipname.c_str(), err);
349        return;
350    }
351    std::string prefix(dir_in_zip + "/");
352    const ZipString prefix_str(prefix.c_str());
353    void* iter_cookie = nullptr;
354    if ((err = StartIteration(zip, &iter_cookie, &prefix_str, nullptr)) != 0) {
355        ALOGE("failed to iterate entries in apk '%s': %d", zipname.c_str(),
356              err);
357        CloseArchive(zip);
358        return;
359    }
360    ALOGD("searching for layers in '%s!/%s'", zipname.c_str(),
361          dir_in_zip.c_str());
362    ZipEntry entry;
363    ZipString name;
364    while (Next(iter_cookie, &entry, &name) == 0) {
365        std::string filename(
366            reinterpret_cast<const char*>(name.name) + prefix.length(),
367            name.name_length - prefix.length());
368        // only enumerate direct entries of the directory, not subdirectories
369        if (filename.find('/') != filename.npos)
370            continue;
371        // Check whether it *may* be possible to load the library directly from
372        // the APK. Loading still may fail for other reasons, but this at least
373        // lets us avoid failed-to-load log messages in the typical case of
374        // compressed and/or unaligned libraries.
375        if (entry.method != kCompressStored || entry.offset % PAGE_SIZE != 0)
376            continue;
377        functor(filename);
378    }
379    EndIteration(iter_cookie);
380    CloseArchive(zip);
381}
382
383template <typename Functor>
384void ForEachFileInPath(const std::string& path, Functor functor) {
385    size_t zip_pos = path.find("!/");
386    if (zip_pos == std::string::npos) {
387        ForEachFileInDir(path, functor);
388    } else {
389        ForEachFileInZip(path.substr(0, zip_pos), path.substr(zip_pos + 2),
390                         functor);
391    }
392}
393
394void DiscoverLayersInPathList(const std::string& pathstr) {
395    std::vector<std::string> paths = android::base::Split(pathstr, ":");
396    for (const auto& path : paths) {
397        ForEachFileInPath(path, [&](const std::string& filename) {
398            if (android::base::StartsWith(filename, "libVkLayer") &&
399                android::base::EndsWith(filename, ".so")) {
400                AddLayerLibrary(path + "/" + filename);
401            }
402        });
403    }
404}
405
406const VkExtensionProperties* FindExtension(
407    const std::vector<VkExtensionProperties>& extensions,
408    const char* name) {
409    auto it = std::find_if(extensions.cbegin(), extensions.cend(),
410                           [=](const VkExtensionProperties& ext) {
411                               return (strcmp(ext.extensionName, name) == 0);
412                           });
413    return (it != extensions.cend()) ? &*it : nullptr;
414}
415
416void* GetLayerGetProcAddr(const Layer& layer,
417                          const char* gpa_name,
418                          size_t gpa_name_len) {
419    const LayerLibrary& library = g_layer_libraries[layer.library_idx];
420    return library.GetGPA(layer, gpa_name, gpa_name_len);
421}
422
423}  // anonymous namespace
424
425void DiscoverLayers() {
426    if (property_get_bool("ro.debuggable", false) &&
427        prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
428        DiscoverLayersInPathList(kSystemLayerLibraryDir);
429    }
430    if (!LoaderData::GetInstance().layer_path.empty())
431        DiscoverLayersInPathList(LoaderData::GetInstance().layer_path);
432}
433
434uint32_t GetLayerCount() {
435    return static_cast<uint32_t>(g_instance_layers.size());
436}
437
438const Layer& GetLayer(uint32_t index) {
439    return g_instance_layers[index];
440}
441
442const Layer* FindLayer(const char* name) {
443    auto layer =
444        std::find_if(g_instance_layers.cbegin(), g_instance_layers.cend(),
445                     [=](const Layer& entry) {
446                         return strcmp(entry.properties.layerName, name) == 0;
447                     });
448    return (layer != g_instance_layers.cend()) ? &*layer : nullptr;
449}
450
451const VkLayerProperties& GetLayerProperties(const Layer& layer) {
452    return layer.properties;
453}
454
455bool IsLayerGlobal(const Layer& layer) {
456    return layer.is_global;
457}
458
459const VkExtensionProperties* GetLayerInstanceExtensions(const Layer& layer,
460                                                        uint32_t& count) {
461    count = static_cast<uint32_t>(layer.instance_extensions.size());
462    return layer.instance_extensions.data();
463}
464
465const VkExtensionProperties* GetLayerDeviceExtensions(const Layer& layer,
466                                                      uint32_t& count) {
467    count = static_cast<uint32_t>(layer.device_extensions.size());
468    return layer.device_extensions.data();
469}
470
471const VkExtensionProperties* FindLayerInstanceExtension(const Layer& layer,
472                                                        const char* name) {
473    return FindExtension(layer.instance_extensions, name);
474}
475
476const VkExtensionProperties* FindLayerDeviceExtension(const Layer& layer,
477                                                      const char* name) {
478    return FindExtension(layer.device_extensions, name);
479}
480
481LayerRef GetLayerRef(const Layer& layer) {
482    LayerLibrary& library = g_layer_libraries[layer.library_idx];
483    return LayerRef((library.Open()) ? &layer : nullptr);
484}
485
486LayerRef::LayerRef(const Layer* layer) : layer_(layer) {}
487
488LayerRef::~LayerRef() {
489    if (layer_) {
490        LayerLibrary& library = g_layer_libraries[layer_->library_idx];
491        library.Close();
492    }
493}
494
495LayerRef::LayerRef(LayerRef&& other) : layer_(other.layer_) {
496    other.layer_ = nullptr;
497}
498
499PFN_vkGetInstanceProcAddr LayerRef::GetGetInstanceProcAddr() const {
500    return layer_ ? reinterpret_cast<PFN_vkGetInstanceProcAddr>(
501                        GetLayerGetProcAddr(*layer_, "GetInstanceProcAddr", 19))
502                  : nullptr;
503}
504
505PFN_vkGetDeviceProcAddr LayerRef::GetGetDeviceProcAddr() const {
506    return layer_ ? reinterpret_cast<PFN_vkGetDeviceProcAddr>(
507                        GetLayerGetProcAddr(*layer_, "GetDeviceProcAddr", 17))
508                  : nullptr;
509}
510
511}  // namespace api
512}  // namespace vulkan
513