blob: 5fae1c4b6fb9907145d2aaed6f5f9e6450f01339 [file] [log] [blame]
/*
* 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>
#include <android-base/logging.h>
#include <cutils/properties.h>
#ifdef LIBHIDL_TARGET_DEBUGGABLE
#include <dirent.h>
#include <dlfcn.h>
#include <regex>
#include <utils/misc.h>
extern "C" __attribute__((weak)) void __sanitizer_cov_dump();
#endif
namespace android {
namespace hardware {
namespace details {
void logAlwaysFatal(const char* message) {
LOG(FATAL) << message;
}
// ----------------------------------------------------------------------
// HidlInstrumentor implementation.
HidlInstrumentor::HidlInstrumentor(const std::string& package, const std::string& interface)
: mEnableInstrumentation(false),
mInstrumentationLibPackage(package),
mInterfaceName(interface) {
configureInstrumentation(false);
#ifdef LIBHIDL_TARGET_DEBUGGABLE
if (__sanitizer_cov_dump != nullptr) {
::android::add_sysprop_change_callback(
[]() {
bool enableCoverage = property_get_bool("hal.coverage.enable", false);
if (enableCoverage) {
__sanitizer_cov_dump();
}
},
0);
}
#endif
}
HidlInstrumentor::~HidlInstrumentor() {}
void HidlInstrumentor::configureInstrumentation(bool log) {
bool enableInstrumentation = property_get_bool(
"hal.instrumentation.enable",
false);
if (enableInstrumentation != mEnableInstrumentation) {
mEnableInstrumentation = enableInstrumentation;
if (mEnableInstrumentation) {
if (log) {
LOG(INFO) << "Enable instrumentation.";
}
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;
char instrumentationLibPath[PROPERTY_VALUE_MAX];
if (property_get("hal.instrumentation.lib.path",
instrumentationLibPath,
"") > 0) {
instrumentationLibPaths.push_back(instrumentationLibPath);
} else {
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_SYSTEM);
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_VENDOR);
instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_ODM);
}
for (auto path : instrumentationLibPaths) {
DIR *dir = opendir(path.c_str());
if (dir == 0) {
LOG(WARNING) << path << " does not exist. ";
return;
}
struct dirent *file;
while ((file = readdir(dir)) != NULL) {
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()) != NULL) {
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