233 lines
8.3 KiB
C++
233 lines
8.3 KiB
C++
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "HidlInternal"
|
|
|
|
#include <hidl/HidlInternal.h>
|
|
|
|
#ifdef __ANDROID__
|
|
#include <android/api-level.h>
|
|
#endif
|
|
#include <android-base/logging.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/stringprintf.h>
|
|
|
|
#ifdef LIBHIDL_TARGET_DEBUGGABLE
|
|
#include <dirent.h>
|
|
#include <dlfcn.h>
|
|
#include <link.h>
|
|
#include <utils/misc.h>
|
|
#include <regex>
|
|
|
|
extern "C" __attribute__((weak)) void __sanitizer_cov_dump();
|
|
|
|
const char kGcovPrefixEnvVar[] = "GCOV_PREFIX";
|
|
const char kGcovPrefixOverrideEnvVar[] = "GCOV_PREFIX_OVERRIDE";
|
|
const char kGcovPrefixPath[] = "/data/misc/trace/";
|
|
const char kSysPropHalCoverage[] = "hal.coverage.enable";
|
|
#if defined(__LP64__)
|
|
const char kSysPropInstrumentationPath[] = "hal.instrumentation.lib.path.64";
|
|
#else
|
|
const char kSysPropInstrumentationPath[] = "hal.instrumentation.lib.path.32";
|
|
#endif
|
|
#endif // LIBHIDL_TARGET_DEBUGGABLE
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace details {
|
|
|
|
void logAlwaysFatal(const char* message) {
|
|
LOG(FATAL) << message;
|
|
}
|
|
|
|
std::string getVndkSpHwPath(const char* lib) {
|
|
static std::string vndk_version = base::GetProperty("ro.vndk.version", "");
|
|
#ifdef __ANDROID__
|
|
static int api_level = android_get_device_api_level();
|
|
if (api_level >= __ANDROID_API_R__) {
|
|
return android::base::StringPrintf("/apex/com.android.vndk.v%s/%s/hw/",
|
|
vndk_version.c_str(), lib);
|
|
}
|
|
#endif
|
|
return android::base::StringPrintf("/system/%s/vndk-sp-%s/hw/", lib, vndk_version.c_str());
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// HidlInstrumentor implementation.
|
|
HidlInstrumentor::HidlInstrumentor(const std::string& package, const std::string& interface)
|
|
: mEnableInstrumentation(false),
|
|
mInstrumentationLibPackage(package),
|
|
mInterfaceName(interface) {
|
|
#ifdef LIBHIDL_TARGET_DEBUGGABLE
|
|
configureInstrumentation(false);
|
|
if (__sanitizer_cov_dump != nullptr) {
|
|
::android::add_sysprop_change_callback(
|
|
[]() {
|
|
bool enableCoverage = base::GetBoolProperty(kSysPropHalCoverage, false);
|
|
if (enableCoverage) {
|
|
__sanitizer_cov_dump();
|
|
}
|
|
},
|
|
0);
|
|
}
|
|
if (base::GetBoolProperty("ro.vts.coverage", false)) {
|
|
const char* prefixOverride = getenv(kGcovPrefixOverrideEnvVar);
|
|
if (prefixOverride == nullptr || strcmp(prefixOverride, "true") != 0) {
|
|
const std::string gcovPath = kGcovPrefixPath + std::to_string(getpid());
|
|
setenv(kGcovPrefixEnvVar, gcovPath.c_str(), true /* overwrite */);
|
|
}
|
|
::android::add_sysprop_change_callback(
|
|
[]() {
|
|
const bool enableCoverage = base::GetBoolProperty(kSysPropHalCoverage, false);
|
|
if (enableCoverage) {
|
|
dl_iterate_phdr(
|
|
[](struct dl_phdr_info* info, size_t /* size */, void* /* data */) {
|
|
if (strlen(info->dlpi_name) == 0) return 0;
|
|
|
|
void* handle = dlopen(info->dlpi_name, RTLD_LAZY);
|
|
if (handle == nullptr) {
|
|
LOG(INFO) << "coverage dlopen failed: " << dlerror();
|
|
return 0;
|
|
}
|
|
void (*flush)() = (void (*)())dlsym(handle, "__gcov_flush");
|
|
if (flush == nullptr) {
|
|
return 0;
|
|
}
|
|
flush();
|
|
return 0;
|
|
},
|
|
nullptr /* data */);
|
|
}
|
|
},
|
|
0 /* priority */);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
HidlInstrumentor::~HidlInstrumentor() {}
|
|
|
|
void HidlInstrumentor::configureInstrumentation(bool log) {
|
|
mEnableInstrumentation = base::GetBoolProperty("hal.instrumentation.enable", false);
|
|
if (mEnableInstrumentation) {
|
|
if (log) {
|
|
LOG(INFO) << "Enable instrumentation.";
|
|
}
|
|
mInstrumentationCallbacks.clear();
|
|
registerInstrumentationCallbacks(&mInstrumentationCallbacks);
|
|
} else {
|
|
if (log) {
|
|
LOG(INFO) << "Disable instrumentation.";
|
|
}
|
|
mInstrumentationCallbacks.clear();
|
|
}
|
|
}
|
|
|
|
void HidlInstrumentor::registerInstrumentationCallbacks(
|
|
std::vector<InstrumentationCallback> *instrumentationCallbacks) {
|
|
#ifdef LIBHIDL_TARGET_DEBUGGABLE
|
|
std::vector<std::string> instrumentationLibPaths;
|
|
const std::string instrumentationLibPath = base::GetProperty(kSysPropInstrumentationPath, "");
|
|
if (instrumentationLibPath.size() > 0) {
|
|
instrumentationLibPaths.push_back(instrumentationLibPath);
|
|
} else {
|
|
static std::string halLibPathVndkSp = getVndkSpHwPath();
|
|
#ifndef __ANDROID_VNDK__
|
|
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_SYSTEM);
|
|
#endif
|
|
instrumentationLibPaths.push_back(halLibPathVndkSp);
|
|
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_VENDOR);
|
|
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_ODM);
|
|
}
|
|
|
|
for (const auto& path : instrumentationLibPaths) {
|
|
DIR *dir = opendir(path.c_str());
|
|
if (dir == nullptr) {
|
|
LOG(WARNING) << path << " does not exist. ";
|
|
return;
|
|
}
|
|
|
|
struct dirent *file;
|
|
while ((file = readdir(dir)) != nullptr) {
|
|
if (!isInstrumentationLib(file))
|
|
continue;
|
|
|
|
void *handle = dlopen((path + file->d_name).c_str(), RTLD_NOW);
|
|
char *error;
|
|
if (handle == nullptr) {
|
|
LOG(WARNING) << "couldn't load file: " << file->d_name
|
|
<< " error: " << dlerror();
|
|
continue;
|
|
}
|
|
|
|
dlerror(); /* Clear any existing error */
|
|
|
|
using cbFun = void (*)(
|
|
const InstrumentationEvent,
|
|
const char *,
|
|
const char *,
|
|
const char *,
|
|
const char *,
|
|
std::vector<void *> *);
|
|
std::string package = mInstrumentationLibPackage;
|
|
for (size_t i = 0; i < package.size(); i++) {
|
|
if (package[i] == '.') {
|
|
package[i] = '_';
|
|
continue;
|
|
}
|
|
|
|
if (package[i] == '@') {
|
|
package[i] = '_';
|
|
package.insert(i + 1, "V");
|
|
continue;
|
|
}
|
|
}
|
|
auto cb = (cbFun)dlsym(handle, ("HIDL_INSTRUMENTATION_FUNCTION_"
|
|
+ package + "_" + mInterfaceName).c_str());
|
|
if ((error = dlerror()) != nullptr) {
|
|
LOG(WARNING)
|
|
<< "couldn't find symbol: HIDL_INSTRUMENTATION_FUNCTION_"
|
|
<< package << "_" << mInterfaceName << ", error: " << error;
|
|
continue;
|
|
}
|
|
instrumentationCallbacks->push_back(cb);
|
|
LOG(INFO) << "Register instrumentation callback from "
|
|
<< file->d_name;
|
|
}
|
|
closedir(dir);
|
|
}
|
|
#else
|
|
// No-op for user builds.
|
|
(void) instrumentationCallbacks;
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
bool HidlInstrumentor::isInstrumentationLib(const dirent *file) {
|
|
#ifdef LIBHIDL_TARGET_DEBUGGABLE
|
|
if (file->d_type != DT_REG) return false;
|
|
std::cmatch cm;
|
|
std::regex e("^" + mInstrumentationLibPackage + "(.*).profiler.so$");
|
|
if (std::regex_match(file->d_name, cm, e)) return true;
|
|
#else
|
|
(void) file;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
} // namespace details
|
|
} // namespace hardware
|
|
} // namespace android
|