Home | History | Annotate | Download | only in base 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "HidlInternal"
     18 
     19 #include <hidl/HidlInternal.h>
     20 
     21 #include <android-base/logging.h>
     22 #include <android-base/properties.h>
     23 #include <android-base/stringprintf.h>
     24 #include <cutils/properties.h>
     25 
     26 #ifdef LIBHIDL_TARGET_DEBUGGABLE
     27 #include <dirent.h>
     28 #include <dlfcn.h>
     29 #include <link.h>
     30 #include <utils/misc.h>
     31 #include <regex>
     32 
     33 extern "C" __attribute__((weak)) void __sanitizer_cov_dump();
     34 const char* kGcovPrefixEnvVar = "GCOV_PREFIX";
     35 const char* kGcovPrefixOverrideEnvVar = "GCOV_PREFIX_OVERRIDE";
     36 const char* kGcovPrefixPath = "/data/misc/trace/";
     37 const char* kSysPropHalCoverage = "hal.coverage.enable";
     38 #if defined(__LP64__)
     39 const char* kSysPropInstrumentationPath = "hal.instrumentation.lib.path.64";
     40 #else
     41 const char* kSysPropInstrumentationPath = "hal.instrumentation.lib.path.32";
     42 #endif
     43 #endif
     44 
     45 namespace android {
     46 namespace hardware {
     47 namespace details {
     48 
     49 void logAlwaysFatal(const char* message) {
     50     LOG(FATAL) << message;
     51 }
     52 
     53 std::string getVndkVersionStr() {
     54     static std::string vndkVersion("0");
     55     // "0" means the vndkVersion must be initialized with the property value.
     56     // Otherwise, return the value.
     57     if (vndkVersion == "0") {
     58         vndkVersion = android::base::GetProperty("ro.vndk.version", "");
     59         if (vndkVersion != "" && vndkVersion != "current") {
     60             vndkVersion = "-" + vndkVersion;
     61         } else {
     62             vndkVersion = "";
     63         }
     64     }
     65     return vndkVersion;
     66 }
     67 
     68 // ----------------------------------------------------------------------
     69 // HidlInstrumentor implementation.
     70 HidlInstrumentor::HidlInstrumentor(const std::string& package, const std::string& interface)
     71     : mEnableInstrumentation(false),
     72       mInstrumentationLibPackage(package),
     73       mInterfaceName(interface) {
     74 #ifdef LIBHIDL_TARGET_DEBUGGABLE
     75     configureInstrumentation(false);
     76     if (__sanitizer_cov_dump != nullptr) {
     77         ::android::add_sysprop_change_callback(
     78             []() {
     79                 bool enableCoverage = property_get_bool(kSysPropHalCoverage, false);
     80                 if (enableCoverage) {
     81                     __sanitizer_cov_dump();
     82                 }
     83             },
     84             0);
     85     }
     86     if (property_get_bool("ro.vts.coverage", false)) {
     87         const char* prefixOverride = getenv(kGcovPrefixOverrideEnvVar);
     88         if (prefixOverride == nullptr || strcmp(prefixOverride, "true") != 0) {
     89             const std::string gcovPath = kGcovPrefixPath + std::to_string(getpid());
     90             setenv(kGcovPrefixEnvVar, gcovPath.c_str(), true /* overwrite */);
     91         }
     92         ::android::add_sysprop_change_callback(
     93             []() {
     94                 const bool enableCoverage = property_get_bool(kSysPropHalCoverage, false);
     95                 if (enableCoverage) {
     96                     dl_iterate_phdr(
     97                         [](struct dl_phdr_info* info, size_t /* size */, void* /* data */) {
     98                             if (strlen(info->dlpi_name) == 0) return 0;
     99 
    100                             void* handle = dlopen(info->dlpi_name, RTLD_LAZY);
    101                             if (handle == nullptr) {
    102                                 LOG(INFO) << "coverage dlopen failed: " << dlerror();
    103                                 return 0;
    104                             }
    105                             void (*flush)() = (void (*)())dlsym(handle, "__gcov_flush");
    106                             if (flush == nullptr) {
    107                                 return 0;
    108                             }
    109                             flush();
    110                             return 0;
    111                         },
    112                         nullptr /* data */);
    113                 }
    114             },
    115             0 /* priority */);
    116     }
    117 #endif
    118 }
    119 
    120 HidlInstrumentor::~HidlInstrumentor() {}
    121 
    122 void HidlInstrumentor::configureInstrumentation(bool log) {
    123     mEnableInstrumentation = property_get_bool("hal.instrumentation.enable", false);
    124     if (mEnableInstrumentation) {
    125         if (log) {
    126             LOG(INFO) << "Enable instrumentation.";
    127         }
    128         mInstrumentationCallbacks.clear();
    129         registerInstrumentationCallbacks(&mInstrumentationCallbacks);
    130     } else {
    131         if (log) {
    132             LOG(INFO) << "Disable instrumentation.";
    133         }
    134         mInstrumentationCallbacks.clear();
    135     }
    136 }
    137 
    138 void HidlInstrumentor::registerInstrumentationCallbacks(
    139         std::vector<InstrumentationCallback> *instrumentationCallbacks) {
    140 #ifdef LIBHIDL_TARGET_DEBUGGABLE
    141     std::vector<std::string> instrumentationLibPaths;
    142     char instrumentationLibPath[PROPERTY_VALUE_MAX];
    143     if (property_get(kSysPropInstrumentationPath, instrumentationLibPath, "") > 0) {
    144         instrumentationLibPaths.push_back(instrumentationLibPath);
    145     } else {
    146         static std::string halLibPathVndkSp = android::base::StringPrintf(
    147             HAL_LIBRARY_PATH_VNDK_SP_FOR_VERSION, getVndkVersionStr().c_str());
    148         instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_SYSTEM);
    149         instrumentationLibPaths.push_back(halLibPathVndkSp);
    150         instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_VENDOR);
    151         instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_ODM);
    152     }
    153 
    154     for (const auto& path : instrumentationLibPaths) {
    155         DIR *dir = opendir(path.c_str());
    156         if (dir == 0) {
    157             LOG(WARNING) << path << " does not exist. ";
    158             return;
    159         }
    160 
    161         struct dirent *file;
    162         while ((file = readdir(dir)) != nullptr) {
    163             if (!isInstrumentationLib(file))
    164                 continue;
    165 
    166             void *handle = dlopen((path + file->d_name).c_str(), RTLD_NOW);
    167             char *error;
    168             if (handle == nullptr) {
    169                 LOG(WARNING) << "couldn't load file: " << file->d_name
    170                     << " error: " << dlerror();
    171                 continue;
    172             }
    173 
    174             dlerror(); /* Clear any existing error */
    175 
    176             using cbFun = void (*)(
    177                     const InstrumentationEvent,
    178                     const char *,
    179                     const char *,
    180                     const char *,
    181                     const char *,
    182                     std::vector<void *> *);
    183             std::string package = mInstrumentationLibPackage;
    184             for (size_t i = 0; i < package.size(); i++) {
    185                 if (package[i] == '.') {
    186                     package[i] = '_';
    187                     continue;
    188                 }
    189 
    190                 if (package[i] == '@') {
    191                     package[i] = '_';
    192                     package.insert(i + 1, "V");
    193                     continue;
    194                 }
    195             }
    196             auto cb = (cbFun)dlsym(handle, ("HIDL_INSTRUMENTATION_FUNCTION_"
    197                         + package + "_" + mInterfaceName).c_str());
    198             if ((error = dlerror()) != nullptr) {
    199                 LOG(WARNING)
    200                     << "couldn't find symbol: HIDL_INSTRUMENTATION_FUNCTION_"
    201                     << package << "_" << mInterfaceName << ", error: " << error;
    202                 continue;
    203             }
    204             instrumentationCallbacks->push_back(cb);
    205             LOG(INFO) << "Register instrumentation callback from "
    206                 << file->d_name;
    207         }
    208         closedir(dir);
    209     }
    210 #else
    211     // No-op for user builds.
    212     (void) instrumentationCallbacks;
    213     return;
    214 #endif
    215 }
    216 
    217 bool HidlInstrumentor::isInstrumentationLib(const dirent *file) {
    218 #ifdef LIBHIDL_TARGET_DEBUGGABLE
    219     if (file->d_type != DT_REG) return false;
    220     std::cmatch cm;
    221     std::regex e("^" + mInstrumentationLibPackage + "(.*).profiler.so$");
    222     if (std::regex_match(file->d_name, cm, e)) return true;
    223 #else
    224     (void) file;
    225 #endif
    226     return false;
    227 }
    228 
    229 }  // namespace details
    230 }  // namespace hardware
    231 }  // namespace android
    232