Home | History | Annotate | Download | only in surfaceflinger
      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 "GpuService.h"
     18 
     19 #include <binder/Parcel.h>
     20 #include <utils/String8.h>
     21 #include <vkjson.h>
     22 
     23 namespace android {
     24 
     25 // ----------------------------------------------------------------------------
     26 
     27 class BpGpuService : public BpInterface<IGpuService>
     28 {
     29 public:
     30     BpGpuService(const sp<IBinder>& impl) : BpInterface<IGpuService>(impl) {}
     31 };
     32 
     33 IMPLEMENT_META_INTERFACE(GpuService, "android.ui.IGpuService");
     34 
     35 status_t BnGpuService::onTransact(uint32_t code, const Parcel& data,
     36         Parcel* reply, uint32_t flags)
     37 {
     38     switch (code) {
     39     case SHELL_COMMAND_TRANSACTION: {
     40         int in = data.readFileDescriptor();
     41         int out = data.readFileDescriptor();
     42         int err = data.readFileDescriptor();
     43         int argc = data.readInt32();
     44         Vector<String16> args;
     45         for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
     46            args.add(data.readString16());
     47         }
     48         return shellCommand(in, out, err, args);
     49     }
     50 
     51     default:
     52         return BBinder::onTransact(code, data, reply, flags);
     53     }
     54 }
     55 
     56 // ----------------------------------------------------------------------------
     57 
     58 namespace {
     59     status_t cmd_help(int out);
     60     status_t cmd_vkjson(int out, int err);
     61 }
     62 
     63 const char* const GpuService::SERVICE_NAME = "gpu";
     64 
     65 GpuService::GpuService() {}
     66 
     67 status_t GpuService::shellCommand(int /*in*/, int out, int err,
     68         Vector<String16>& args)
     69 {
     70     ALOGV("GpuService::shellCommand");
     71     for (size_t i = 0, n = args.size(); i < n; i++)
     72         ALOGV("  arg[%zu]: '%s'", i, String8(args[i]).string());
     73 
     74     if (args[0] == String16("vkjson"))
     75         return cmd_vkjson(out, err);
     76     else if (args[0] == String16("help"))
     77         return cmd_help(out);
     78 
     79     return NO_ERROR;
     80 }
     81 
     82 // ----------------------------------------------------------------------------
     83 
     84 namespace {
     85 
     86 status_t cmd_help(int out) {
     87     FILE* outs = fdopen(out, "w");
     88     if (!outs) {
     89         ALOGE("vkjson: failed to create out stream: %s (%d)", strerror(errno),
     90             errno);
     91         return BAD_VALUE;
     92     }
     93     fprintf(outs,
     94         "GPU Service commands:\n"
     95         "  vkjson   dump Vulkan device capabilities as JSON\n");
     96     fclose(outs);
     97     return NO_ERROR;
     98 }
     99 
    100 VkResult vkjsonPrint(FILE* out, FILE* err) {
    101     VkResult result;
    102 
    103     const VkApplicationInfo app_info = {
    104         VK_STRUCTURE_TYPE_APPLICATION_INFO, nullptr,
    105         "vkjson", 1,    /* app name, version */
    106         "", 0,          /* engine name, version */
    107         VK_API_VERSION_1_0
    108     };
    109     const VkInstanceCreateInfo instance_info = {
    110         VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, nullptr,
    111         0,              /* flags */
    112         &app_info,
    113         0, nullptr,     /* layers */
    114         0, nullptr,     /* extensions */
    115     };
    116     VkInstance instance;
    117     result = vkCreateInstance(&instance_info, nullptr, &instance);
    118     if (result != VK_SUCCESS) {
    119         fprintf(err, "vkCreateInstance failed: %d\n", result);
    120         return result;
    121     }
    122 
    123     uint32_t ngpu = 0;
    124     result = vkEnumeratePhysicalDevices(instance, &ngpu, nullptr);
    125     if (result != VK_SUCCESS) {
    126         fprintf(err, "vkEnumeratePhysicalDevices failed: %d\n", result);
    127         return result;
    128     }
    129     std::vector<VkPhysicalDevice> gpus(ngpu, VK_NULL_HANDLE);
    130     result = vkEnumeratePhysicalDevices(instance, &ngpu, gpus.data());
    131     if (result != VK_SUCCESS) {
    132         fprintf(err, "vkEnumeratePhysicalDevices failed: %d\n", result);
    133         return result;
    134     }
    135 
    136     for (size_t i = 0, n = gpus.size(); i < n; i++) {
    137         auto props = VkJsonGetAllProperties(gpus[i]);
    138         std::string json = VkJsonAllPropertiesToJson(props);
    139         fwrite(json.data(), 1, json.size(), out);
    140         if (i < n - 1)
    141             fputc(',', out);
    142         fputc('\n', out);
    143     }
    144 
    145     vkDestroyInstance(instance, nullptr);
    146 
    147     return VK_SUCCESS;
    148 }
    149 
    150 status_t cmd_vkjson(int out, int err) {
    151     int errnum;
    152     FILE* outs = fdopen(out, "w");
    153     if (!outs) {
    154         errnum = errno;
    155         ALOGE("vkjson: failed to create output stream: %s", strerror(errnum));
    156         return -errnum;
    157     }
    158     FILE* errs = fdopen(err, "w");
    159     if (!errs) {
    160         errnum = errno;
    161         ALOGE("vkjson: failed to create error stream: %s", strerror(errnum));
    162         fclose(outs);
    163         return -errnum;
    164     }
    165     fprintf(outs, "[\n");
    166     VkResult result = vkjsonPrint(outs, errs);
    167     fprintf(outs, "]\n");
    168     fclose(errs);
    169     fclose(outs);
    170     return result >= 0 ? NO_ERROR : UNKNOWN_ERROR;
    171 }
    172 
    173 } // anonymous namespace
    174 
    175 } // namespace android
    176