Merge "Revert "SurfaceFlinger: setGeometryAppliesWithResize crop latching fixes."" into oc-dev
diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp
index 4740202..38647eb 100644
--- a/cmds/lshal/Android.bp
+++ b/cmds/lshal/Android.bp
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-cc_binary {
- name: "lshal",
+cc_library_shared {
+ name: "liblshal",
shared_libs: [
"libbase",
"libcutils",
@@ -25,7 +25,44 @@
"android.hidl.manager@1.0",
],
srcs: [
+ "DebugCommand.cpp",
"Lshal.cpp",
- "PipeRelay.cpp"
+ "ListCommand.cpp",
+ "PipeRelay.cpp",
+ "utils.cpp",
],
}
+
+cc_defaults {
+ name: "lshal_defaults",
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "liblshal",
+ "libutils",
+ ]
+}
+
+cc_binary {
+ name: "lshal",
+ defaults: ["lshal_defaults"],
+ srcs: [
+ "main.cpp"
+ ]
+}
+
+cc_test {
+ name: "lshal_test",
+ defaults: ["lshal_defaults"],
+ gtest: true,
+ static_libs: [
+ "libgmock"
+ ],
+ shared_libs: [
+ "android.hardware.tests.baz@1.0"
+ ],
+ srcs: [
+ "test.cpp"
+ ]
+}
diff --git a/cmds/lshal/DebugCommand.cpp b/cmds/lshal/DebugCommand.cpp
new file mode 100644
index 0000000..672cad6
--- /dev/null
+++ b/cmds/lshal/DebugCommand.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "DebugCommand.h"
+
+#include "Lshal.h"
+
+namespace android {
+namespace lshal {
+
+DebugCommand::DebugCommand(Lshal &lshal) : mLshal(lshal) {
+}
+
+Status DebugCommand::parseArgs(const std::string &command, const Arg &arg) {
+ if (optind >= arg.argc) {
+ mLshal.usage(command);
+ return USAGE;
+ }
+ mInterfaceName = arg.argv[optind];
+ ++optind;
+ for (; optind < arg.argc; ++optind) {
+ mOptions.push_back(arg.argv[optind]);
+ }
+ return OK;
+}
+
+Status DebugCommand::main(const std::string &command, const Arg &arg) {
+ Status status = parseArgs(command, arg);
+ if (status != OK) {
+ return status;
+ }
+ auto pair = splitFirst(mInterfaceName, '/');
+ return mLshal.emitDebugInfo(
+ pair.first, pair.second.empty() ? "default" : pair.second, mOptions,
+ mLshal.out().buf(),
+ mLshal.err());
+}
+
+} // namespace lshal
+} // namespace android
+
diff --git a/cmds/lshal/DebugCommand.h b/cmds/lshal/DebugCommand.h
new file mode 100644
index 0000000..fa0f0fa
--- /dev/null
+++ b/cmds/lshal/DebugCommand.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_DEBUG_COMMAND_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_DEBUG_COMMAND_H_
+
+#include <string>
+
+#include <android-base/macros.h>
+
+#include "utils.h"
+
+namespace android {
+namespace lshal {
+
+class Lshal;
+
+class DebugCommand {
+public:
+ DebugCommand(Lshal &lshal);
+ Status main(const std::string &command, const Arg &arg);
+private:
+ Status parseArgs(const std::string &command, const Arg &arg);
+
+ Lshal &mLshal;
+ std::string mInterfaceName;
+ std::vector<std::string> mOptions;
+
+ DISALLOW_COPY_AND_ASSIGN(DebugCommand);
+};
+
+
+} // namespace lshal
+} // namespace android
+
+#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_DEBUG_COMMAND_H_
diff --git a/cmds/lshal/ListCommand.cpp b/cmds/lshal/ListCommand.cpp
new file mode 100644
index 0000000..710b6e4
--- /dev/null
+++ b/cmds/lshal/ListCommand.cpp
@@ -0,0 +1,705 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "ListCommand.h"
+
+#include <getopt.h>
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <regex>
+
+#include <android-base/parseint.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl-util/FQName.h>
+#include <private/android_filesystem_config.h>
+#include <sys/stat.h>
+#include <vintf/HalManifest.h>
+#include <vintf/parse_xml.h>
+
+#include "Lshal.h"
+#include "PipeRelay.h"
+#include "Timeout.h"
+#include "utils.h"
+
+using ::android::hardware::hidl_string;
+using ::android::hidl::manager::V1_0::IServiceManager;
+
+namespace android {
+namespace lshal {
+
+ListCommand::ListCommand(Lshal &lshal) : mLshal(lshal), mErr(lshal.err()), mOut(lshal.out()) {
+}
+
+std::string getCmdline(pid_t pid) {
+ std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
+ std::string cmdline;
+ if (!ifs.is_open()) {
+ return "";
+ }
+ ifs >> cmdline;
+ return cmdline;
+}
+
+const std::string &ListCommand::getCmdline(pid_t pid) {
+ auto pair = mCmdlines.find(pid);
+ if (pair != mCmdlines.end()) {
+ return pair->second;
+ }
+ mCmdlines[pid] = ::android::lshal::getCmdline(pid);
+ return mCmdlines[pid];
+}
+
+void ListCommand::removeDeadProcesses(Pids *pids) {
+ static const pid_t myPid = getpid();
+ pids->erase(std::remove_if(pids->begin(), pids->end(), [this](auto pid) {
+ return pid == myPid || this->getCmdline(pid).empty();
+ }), pids->end());
+}
+
+bool ListCommand::getReferencedPids(
+ pid_t serverPid, std::map<uint64_t, Pids> *objects) const {
+
+ std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
+ if (!ifs.is_open()) {
+ return false;
+ }
+
+ static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
+
+ std::string line;
+ std::smatch match;
+ while(getline(ifs, line)) {
+ if (!std::regex_search(line, match, prefix)) {
+ // the line doesn't start with the correct prefix
+ continue;
+ }
+ std::string ptrString = "0x" + match.str(2); // use number after c
+ uint64_t ptr;
+ if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
+ // Should not reach here, but just be tolerant.
+ mErr << "Could not parse number " << ptrString << std::endl;
+ continue;
+ }
+ const std::string proc = " proc ";
+ auto pos = line.rfind(proc);
+ if (pos != std::string::npos) {
+ for (const std::string &pidStr : split(line.substr(pos + proc.size()), ' ')) {
+ int32_t pid;
+ if (!::android::base::ParseInt(pidStr, &pid)) {
+ mErr << "Could not parse number " << pidStr << std::endl;
+ continue;
+ }
+ (*objects)[ptr].push_back(pid);
+ }
+ }
+ }
+ return true;
+}
+
+// Must process hwbinder services first, then passthrough services.
+void ListCommand::forEachTable(const std::function<void(Table &)> &f) {
+ f(mServicesTable);
+ f(mPassthroughRefTable);
+ f(mImplementationsTable);
+}
+void ListCommand::forEachTable(const std::function<void(const Table &)> &f) const {
+ f(mServicesTable);
+ f(mPassthroughRefTable);
+ f(mImplementationsTable);
+}
+
+void ListCommand::postprocess() {
+ forEachTable([this](Table &table) {
+ if (mSortColumn) {
+ std::sort(table.begin(), table.end(), mSortColumn);
+ }
+ for (TableEntry &entry : table) {
+ entry.serverCmdline = getCmdline(entry.serverPid);
+ removeDeadProcesses(&entry.clientPids);
+ for (auto pid : entry.clientPids) {
+ entry.clientCmdlines.push_back(this->getCmdline(pid));
+ }
+ }
+ });
+ // use a double for loop here because lshal doesn't care about efficiency.
+ for (TableEntry &packageEntry : mImplementationsTable) {
+ std::string packageName = packageEntry.interfaceName;
+ FQName fqPackageName{packageName.substr(0, packageName.find("::"))};
+ if (!fqPackageName.isValid()) {
+ continue;
+ }
+ for (TableEntry &interfaceEntry : mPassthroughRefTable) {
+ if (interfaceEntry.arch != ARCH_UNKNOWN) {
+ continue;
+ }
+ FQName interfaceName{splitFirst(interfaceEntry.interfaceName, '/').first};
+ if (!interfaceName.isValid()) {
+ continue;
+ }
+ if (interfaceName.getPackageAndVersion() == fqPackageName) {
+ interfaceEntry.arch = packageEntry.arch;
+ }
+ }
+ }
+}
+
+void ListCommand::printLine(
+ const std::string &interfaceName,
+ const std::string &transport,
+ const std::string &arch,
+ const std::string &server,
+ const std::string &serverCmdline,
+ const std::string &address, const std::string &clients,
+ const std::string &clientCmdlines) const {
+ if (mSelectedColumns & ENABLE_INTERFACE_NAME)
+ mOut << std::setw(80) << interfaceName << "\t";
+ if (mSelectedColumns & ENABLE_TRANSPORT)
+ mOut << std::setw(10) << transport << "\t";
+ if (mSelectedColumns & ENABLE_ARCH)
+ mOut << std::setw(5) << arch << "\t";
+ if (mSelectedColumns & ENABLE_SERVER_PID) {
+ if (mEnableCmdlines) {
+ mOut << std::setw(15) << serverCmdline << "\t";
+ } else {
+ mOut << std::setw(5) << server << "\t";
+ }
+ }
+ if (mSelectedColumns & ENABLE_SERVER_ADDR)
+ mOut << std::setw(16) << address << "\t";
+ if (mSelectedColumns & ENABLE_CLIENT_PIDS) {
+ if (mEnableCmdlines) {
+ mOut << std::setw(0) << clientCmdlines;
+ } else {
+ mOut << std::setw(0) << clients;
+ }
+ }
+ mOut << std::endl;
+}
+
+void ListCommand::dumpVintf() const {
+ mOut << "<!-- " << std::endl
+ << " This is a skeleton device manifest. Notes: " << std::endl
+ << " 1. android.hidl.*, android.frameworks.*, android.system.* are not included." << std::endl
+ << " 2. If a HAL is supported in both hwbinder and passthrough transport, " << std::endl
+ << " only hwbinder is shown." << std::endl
+ << " 3. It is likely that HALs in passthrough transport does not have" << std::endl
+ << " <interface> declared; users will have to write them by hand." << std::endl
+ << " 4. sepolicy version is set to 0.0. It is recommended that the entry" << std::endl
+ << " is removed from the manifest file and written by assemble_vintf" << std::endl
+ << " at build time." << std::endl
+ << "-->" << std::endl;
+
+ vintf::HalManifest manifest;
+ forEachTable([this, &manifest] (const Table &table) {
+ for (const TableEntry &entry : table) {
+
+ std::string fqInstanceName = entry.interfaceName;
+
+ if (&table == &mImplementationsTable) {
+ // Quick hack to work around *'s
+ replaceAll(&fqInstanceName, '*', 'D');
+ }
+ auto splittedFqInstanceName = splitFirst(fqInstanceName, '/');
+ FQName fqName(splittedFqInstanceName.first);
+ if (!fqName.isValid()) {
+ mErr << "Warning: '" << splittedFqInstanceName.first
+ << "' is not a valid FQName." << std::endl;
+ continue;
+ }
+ // Strip out system libs.
+ if (fqName.inPackage("android.hidl") ||
+ fqName.inPackage("android.frameworks") ||
+ fqName.inPackage("android.system")) {
+ continue;
+ }
+ std::string interfaceName =
+ &table == &mImplementationsTable ? "" : fqName.name();
+ std::string instanceName =
+ &table == &mImplementationsTable ? "" : splittedFqInstanceName.second;
+
+ vintf::Version version{fqName.getPackageMajorVersion(),
+ fqName.getPackageMinorVersion()};
+ vintf::Transport transport;
+ vintf::Arch arch;
+ if (entry.transport == "hwbinder") {
+ transport = vintf::Transport::HWBINDER;
+ arch = vintf::Arch::ARCH_EMPTY;
+ } else if (entry.transport == "passthrough") {
+ transport = vintf::Transport::PASSTHROUGH;
+ switch (entry.arch) {
+ case lshal::ARCH32:
+ arch = vintf::Arch::ARCH_32; break;
+ case lshal::ARCH64:
+ arch = vintf::Arch::ARCH_64; break;
+ case lshal::ARCH_BOTH:
+ arch = vintf::Arch::ARCH_32_64; break;
+ case lshal::ARCH_UNKNOWN: // fallthrough
+ default:
+ mErr << "Warning: '" << fqName.package()
+ << "' doesn't have bitness info, assuming 32+64." << std::endl;
+ arch = vintf::Arch::ARCH_32_64;
+ }
+ } else {
+ mErr << "Warning: '" << entry.transport << "' is not a valid transport." << std::endl;
+ continue;
+ }
+
+ bool done = false;
+ for (vintf::ManifestHal *hal : manifest.getHals(fqName.package())) {
+ if (hal->transport() != transport) {
+ if (transport != vintf::Transport::PASSTHROUGH) {
+ mErr << "Fatal: should not reach here. Generated result may be wrong."
+ << std::endl;
+ }
+ done = true;
+ break;
+ }
+ if (hal->hasVersion(version)) {
+ if (&table != &mImplementationsTable) {
+ hal->interfaces[interfaceName].name = interfaceName;
+ hal->interfaces[interfaceName].instances.insert(instanceName);
+ }
+ done = true;
+ break;
+ }
+ }
+ if (done) {
+ continue; // to next TableEntry
+ }
+ decltype(vintf::ManifestHal::interfaces) interfaces;
+ if (&table != &mImplementationsTable) {
+ interfaces[interfaceName].name = interfaceName;
+ interfaces[interfaceName].instances.insert(instanceName);
+ }
+ if (!manifest.add(vintf::ManifestHal{
+ .format = vintf::HalFormat::HIDL,
+ .name = fqName.package(),
+ .versions = {version},
+ .transportArch = {transport, arch},
+ .interfaces = interfaces})) {
+ mErr << "Warning: cannot add hal '" << fqInstanceName << "'" << std::endl;
+ }
+ }
+ });
+ mOut << vintf::gHalManifestConverter(manifest);
+}
+
+static const std::string &getArchString(Architecture arch) {
+ static const std::string sStr64 = "64";
+ static const std::string sStr32 = "32";
+ static const std::string sStrBoth = "32+64";
+ static const std::string sStrUnknown = "";
+ switch (arch) {
+ case ARCH64:
+ return sStr64;
+ case ARCH32:
+ return sStr32;
+ case ARCH_BOTH:
+ return sStrBoth;
+ case ARCH_UNKNOWN: // fall through
+ default:
+ return sStrUnknown;
+ }
+}
+
+static Architecture fromBaseArchitecture(::android::hidl::base::V1_0::DebugInfo::Architecture a) {
+ switch (a) {
+ case ::android::hidl::base::V1_0::DebugInfo::Architecture::IS_64BIT:
+ return ARCH64;
+ case ::android::hidl::base::V1_0::DebugInfo::Architecture::IS_32BIT:
+ return ARCH32;
+ case ::android::hidl::base::V1_0::DebugInfo::Architecture::UNKNOWN: // fallthrough
+ default:
+ return ARCH_UNKNOWN;
+ }
+}
+
+void ListCommand::dumpTable() {
+ mServicesTable.description =
+ "All binderized services (registered services through hwservicemanager)";
+ mPassthroughRefTable.description =
+ "All interfaces that getService() has ever return as a passthrough interface;\n"
+ "PIDs / processes shown below might be inaccurate because the process\n"
+ "might have relinquished the interface or might have died.\n"
+ "The Server / Server CMD column can be ignored.\n"
+ "The Clients / Clients CMD column shows all process that have ever dlopen'ed \n"
+ "the library and successfully fetched the passthrough implementation.";
+ mImplementationsTable.description =
+ "All available passthrough implementations (all -impl.so files)";
+ forEachTable([this] (const Table &table) {
+ mOut << table.description << std::endl;
+ mOut << std::left;
+ printLine("Interface", "Transport", "Arch", "Server", "Server CMD",
+ "PTR", "Clients", "Clients CMD");
+
+ for (const auto &entry : table) {
+ printLine(entry.interfaceName,
+ entry.transport,
+ getArchString(entry.arch),
+ entry.serverPid == NO_PID ? "N/A" : std::to_string(entry.serverPid),
+ entry.serverCmdline,
+ entry.serverObjectAddress == NO_PTR ? "N/A" : toHexString(entry.serverObjectAddress),
+ join(entry.clientPids, " "),
+ join(entry.clientCmdlines, ";"));
+
+ // We're only interested in dumping debug info for already
+ // instantiated services. There's little value in dumping the
+ // debug info for a service we create on the fly, so we only operate
+ // on the "mServicesTable".
+ if (mEmitDebugInfo && &table == &mServicesTable) {
+ auto pair = splitFirst(entry.interfaceName, '/');
+ mLshal.emitDebugInfo(pair.first, pair.second, {}, mOut.buf(),
+ NullableOStream<std::ostream>(nullptr));
+ }
+ }
+ mOut << std::endl;
+ });
+
+}
+
+void ListCommand::dump() {
+ if (mVintf) {
+ dumpVintf();
+ if (!!mFileOutput) {
+ mFileOutput.buf().close();
+ delete &mFileOutput.buf();
+ mFileOutput = nullptr;
+ }
+ mOut = std::cout;
+ } else {
+ dumpTable();
+ }
+}
+
+void ListCommand::putEntry(TableEntrySource source, TableEntry &&entry) {
+ Table *table = nullptr;
+ switch (source) {
+ case HWSERVICEMANAGER_LIST :
+ table = &mServicesTable; break;
+ case PTSERVICEMANAGER_REG_CLIENT :
+ table = &mPassthroughRefTable; break;
+ case LIST_DLLIB :
+ table = &mImplementationsTable; break;
+ default:
+ mErr << "Error: Unknown source of entry " << source << std::endl;
+ }
+ if (table) {
+ table->entries.push_back(std::forward<TableEntry>(entry));
+ }
+}
+
+Status ListCommand::fetchAllLibraries(const sp<IServiceManager> &manager) {
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
+ std::map<std::string, TableEntry> entries;
+ for (const auto &info : infos) {
+ std::string interfaceName = std::string{info.interfaceName.c_str()} + "/" +
+ std::string{info.instanceName.c_str()};
+ entries.emplace(interfaceName, TableEntry{
+ .interfaceName = interfaceName,
+ .transport = "passthrough",
+ .serverPid = NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = {},
+ .arch = ARCH_UNKNOWN
+ }).first->second.arch |= fromBaseArchitecture(info.arch);
+ }
+ for (auto &&pair : entries) {
+ putEntry(LIST_DLLIB, std::move(pair.second));
+ }
+ });
+ if (!ret.isOk()) {
+ mErr << "Error: Failed to call list on getPassthroughServiceManager(): "
+ << ret.description() << std::endl;
+ return DUMP_ALL_LIBS_ERROR;
+ }
+ return OK;
+}
+
+Status ListCommand::fetchPassthrough(const sp<IServiceManager> &manager) {
+ using namespace ::android::hardware;
+ using namespace ::android::hardware::details;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
+ for (const auto &info : infos) {
+ if (info.clientPids.size() <= 0) {
+ continue;
+ }
+ putEntry(PTSERVICEMANAGER_REG_CLIENT, {
+ .interfaceName =
+ std::string{info.interfaceName.c_str()} + "/" +
+ std::string{info.instanceName.c_str()},
+ .transport = "passthrough",
+ .serverPid = info.clientPids.size() == 1 ? info.clientPids[0] : NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = info.clientPids,
+ .arch = fromBaseArchitecture(info.arch)
+ });
+ }
+ });
+ if (!ret.isOk()) {
+ mErr << "Error: Failed to call debugDump on defaultServiceManager(): "
+ << ret.description() << std::endl;
+ return DUMP_PASSTHROUGH_ERROR;
+ }
+ return OK;
+}
+
+Status ListCommand::fetchBinderized(const sp<IServiceManager> &manager) {
+ using namespace ::std;
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ const std::string mode = "hwbinder";
+
+ hidl_vec<hidl_string> fqInstanceNames;
+ // copying out for timeoutIPC
+ auto listRet = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &names) {
+ fqInstanceNames = names;
+ });
+ if (!listRet.isOk()) {
+ mErr << "Error: Failed to list services for " << mode << ": "
+ << listRet.description() << std::endl;
+ return DUMP_BINDERIZED_ERROR;
+ }
+
+ Status status = OK;
+ // server pid, .ptr value of binder object, child pids
+ std::map<std::string, DebugInfo> allDebugInfos;
+ std::map<pid_t, std::map<uint64_t, Pids>> allPids;
+ for (const auto &fqInstanceName : fqInstanceNames) {
+ const auto pair = splitFirst(fqInstanceName, '/');
+ const auto &serviceName = pair.first;
+ const auto &instanceName = pair.second;
+ auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName);
+ if (!getRet.isOk()) {
+ mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+ << "cannot be fetched from service manager:"
+ << getRet.description() << std::endl;
+ status |= DUMP_BINDERIZED_ERROR;
+ continue;
+ }
+ sp<IBase> service = getRet;
+ if (service == nullptr) {
+ mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+ << "cannot be fetched from service manager (null)"
+ << std::endl;
+ status |= DUMP_BINDERIZED_ERROR;
+ continue;
+ }
+ auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &debugInfo) {
+ allDebugInfos[fqInstanceName] = debugInfo;
+ if (debugInfo.pid >= 0) {
+ allPids[static_cast<pid_t>(debugInfo.pid)].clear();
+ }
+ });
+ if (!debugRet.isOk()) {
+ mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+ << "debugging information cannot be retrieved:"
+ << debugRet.description() << std::endl;
+ status |= DUMP_BINDERIZED_ERROR;
+ }
+ }
+ for (auto &pair : allPids) {
+ pid_t serverPid = pair.first;
+ if (!getReferencedPids(serverPid, &allPids[serverPid])) {
+ mErr << "Warning: no information for PID " << serverPid
+ << ", are you root?" << std::endl;
+ status |= DUMP_BINDERIZED_ERROR;
+ }
+ }
+ for (const auto &fqInstanceName : fqInstanceNames) {
+ auto it = allDebugInfos.find(fqInstanceName);
+ if (it == allDebugInfos.end()) {
+ putEntry(HWSERVICEMANAGER_LIST, {
+ .interfaceName = fqInstanceName,
+ .transport = mode,
+ .serverPid = NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = {},
+ .arch = ARCH_UNKNOWN
+ });
+ continue;
+ }
+ const DebugInfo &info = it->second;
+ putEntry(HWSERVICEMANAGER_LIST, {
+ .interfaceName = fqInstanceName,
+ .transport = mode,
+ .serverPid = info.pid,
+ .serverObjectAddress = info.ptr,
+ .clientPids = info.pid == NO_PID || info.ptr == NO_PTR
+ ? Pids{} : allPids[info.pid][info.ptr],
+ .arch = fromBaseArchitecture(info.arch),
+ });
+ }
+ return status;
+}
+
+Status ListCommand::fetch() {
+ Status status = OK;
+ auto bManager = mLshal.serviceManager();
+ if (bManager == nullptr) {
+ mErr << "Failed to get defaultServiceManager()!" << std::endl;
+ status |= NO_BINDERIZED_MANAGER;
+ } else {
+ status |= fetchBinderized(bManager);
+ // Passthrough PIDs are registered to the binderized manager as well.
+ status |= fetchPassthrough(bManager);
+ }
+
+ auto pManager = mLshal.passthroughManager();
+ if (pManager == nullptr) {
+ mErr << "Failed to get getPassthroughServiceManager()!" << std::endl;
+ status |= NO_PASSTHROUGH_MANAGER;
+ } else {
+ status |= fetchAllLibraries(pManager);
+ }
+ return status;
+}
+
+Status ListCommand::parseArgs(const std::string &command, const Arg &arg) {
+ static struct option longOptions[] = {
+ // long options with short alternatives
+ {"help", no_argument, 0, 'h' },
+ {"interface", no_argument, 0, 'i' },
+ {"transport", no_argument, 0, 't' },
+ {"arch", no_argument, 0, 'r' },
+ {"pid", no_argument, 0, 'p' },
+ {"address", no_argument, 0, 'a' },
+ {"clients", no_argument, 0, 'c' },
+ {"cmdline", no_argument, 0, 'm' },
+ {"debug", optional_argument, 0, 'd' },
+
+ // long options without short alternatives
+ {"sort", required_argument, 0, 's' },
+ {"init-vintf",optional_argument, 0, 'v' },
+ { 0, 0, 0, 0 }
+ };
+
+ int optionIndex;
+ int c;
+ // Lshal::parseArgs has set optind to the next option to parse
+ for (;;) {
+ // using getopt_long in case we want to add other options in the future
+ c = getopt_long(arg.argc, arg.argv,
+ "hitrpacmd", longOptions, &optionIndex);
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 's': {
+ if (strcmp(optarg, "interface") == 0 || strcmp(optarg, "i") == 0) {
+ mSortColumn = TableEntry::sortByInterfaceName;
+ } else if (strcmp(optarg, "pid") == 0 || strcmp(optarg, "p") == 0) {
+ mSortColumn = TableEntry::sortByServerPid;
+ } else {
+ mErr << "Unrecognized sorting column: " << optarg << std::endl;
+ mLshal.usage(command);
+ return USAGE;
+ }
+ break;
+ }
+ case 'v': {
+ if (optarg) {
+ mFileOutput = new std::ofstream{optarg};
+ mOut = mFileOutput;
+ if (!mFileOutput.buf().is_open()) {
+ mErr << "Could not open file '" << optarg << "'." << std::endl;
+ return IO_ERROR;
+ }
+ }
+ mVintf = true;
+ }
+ case 'i': {
+ mSelectedColumns |= ENABLE_INTERFACE_NAME;
+ break;
+ }
+ case 't': {
+ mSelectedColumns |= ENABLE_TRANSPORT;
+ break;
+ }
+ case 'r': {
+ mSelectedColumns |= ENABLE_ARCH;
+ break;
+ }
+ case 'p': {
+ mSelectedColumns |= ENABLE_SERVER_PID;
+ break;
+ }
+ case 'a': {
+ mSelectedColumns |= ENABLE_SERVER_ADDR;
+ break;
+ }
+ case 'c': {
+ mSelectedColumns |= ENABLE_CLIENT_PIDS;
+ break;
+ }
+ case 'm': {
+ mEnableCmdlines = true;
+ break;
+ }
+ case 'd': {
+ mEmitDebugInfo = true;
+
+ if (optarg) {
+ mFileOutput = new std::ofstream{optarg};
+ mOut = mFileOutput;
+ if (!mFileOutput.buf().is_open()) {
+ mErr << "Could not open file '" << optarg << "'." << std::endl;
+ return IO_ERROR;
+ }
+ chown(optarg, AID_SHELL, AID_SHELL);
+ }
+ break;
+ }
+ case 'h': // falls through
+ default: // see unrecognized options
+ mLshal.usage(command);
+ return USAGE;
+ }
+ }
+ if (optind < arg.argc) {
+ // see non option
+ mErr << "Unrecognized option `" << arg.argv[optind] << "`" << std::endl;
+ }
+
+ if (mSelectedColumns == 0) {
+ mSelectedColumns = ENABLE_INTERFACE_NAME | ENABLE_SERVER_PID | ENABLE_CLIENT_PIDS;
+ }
+ return OK;
+}
+
+Status ListCommand::main(const std::string &command, const Arg &arg) {
+ Status status = parseArgs(command, arg);
+ if (status != OK) {
+ return status;
+ }
+ status = fetch();
+ postprocess();
+ dump();
+ return status;
+}
+
+} // namespace lshal
+} // namespace android
+
diff --git a/cmds/lshal/ListCommand.h b/cmds/lshal/ListCommand.h
new file mode 100644
index 0000000..42c965f
--- /dev/null
+++ b/cmds/lshal/ListCommand.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_LIST_COMMAND_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_LIST_COMMAND_H_
+
+#include <stdint.h>
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include <android-base/macros.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+
+#include "NullableOStream.h"
+#include "TableEntry.h"
+#include "utils.h"
+
+namespace android {
+namespace lshal {
+
+class Lshal;
+
+class ListCommand {
+public:
+ ListCommand(Lshal &lshal);
+ Status main(const std::string &command, const Arg &arg);
+private:
+ Status parseArgs(const std::string &command, const Arg &arg);
+ Status fetch();
+ void postprocess();
+ void dump();
+ void putEntry(TableEntrySource source, TableEntry &&entry);
+ Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ Status fetchBinderized(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ bool getReferencedPids(
+ pid_t serverPid, std::map<uint64_t, Pids> *objects) const;
+ void dumpTable();
+ void dumpVintf() const;
+ void printLine(
+ const std::string &interfaceName,
+ const std::string &transport,
+ const std::string &arch,
+ const std::string &server,
+ const std::string &serverCmdline,
+ const std::string &address, const std::string &clients,
+ const std::string &clientCmdlines) const ;
+ // Return /proc/{pid}/cmdline if it exists, else empty string.
+ const std::string &getCmdline(pid_t pid);
+ // Call getCmdline on all pid in pids. If it returns empty string, the process might
+ // have died, and the pid is removed from pids.
+ void removeDeadProcesses(Pids *pids);
+ void forEachTable(const std::function<void(Table &)> &f);
+ void forEachTable(const std::function<void(const Table &)> &f) const;
+
+ Lshal &mLshal;
+
+ Table mServicesTable{};
+ Table mPassthroughRefTable{};
+ Table mImplementationsTable{};
+
+ NullableOStream<std::ostream> mErr;
+ NullableOStream<std::ostream> mOut;
+ NullableOStream<std::ofstream> mFileOutput = nullptr;
+ TableEntryCompare mSortColumn = nullptr;
+ TableEntrySelect mSelectedColumns = 0;
+ // If true, cmdlines will be printed instead of pid.
+ bool mEnableCmdlines = false;
+
+ // If true, calls IBase::debug(...) on each service.
+ bool mEmitDebugInfo = false;
+
+ bool mVintf = false;
+ // If an entry does not exist, need to ask /proc/{pid}/cmdline to get it.
+ // If an entry exist but is an empty string, process might have died.
+ // If an entry exist and not empty, it contains the cached content of /proc/{pid}/cmdline.
+ std::map<pid_t, std::string> mCmdlines;
+
+ DISALLOW_COPY_AND_ASSIGN(ListCommand);
+};
+
+
+} // namespace lshal
+} // namespace android
+
+#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_LIST_COMMAND_H_
diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp
index 85d8938..9db42f1 100644
--- a/cmds/lshal/Lshal.cpp
+++ b/cmds/lshal/Lshal.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2016 The Android Open Source Project
+ * Copyright (C) 2017 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.
@@ -14,399 +14,155 @@
* limitations under the License.
*/
+#define LOG_TAG "lshal"
+#include <android-base/logging.h>
+
#include "Lshal.h"
-#include <getopt.h>
+#include <set>
+#include <string>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <map>
-#include <sstream>
-#include <regex>
-
-#include <android-base/logging.h>
-#include <android-base/parseint.h>
-#include <android/hidl/manager/1.0/IServiceManager.h>
#include <hidl/ServiceManagement.h>
-#include <hidl-util/FQName.h>
-#include <private/android_filesystem_config.h>
-#include <sys/stat.h>
-#include <vintf/HalManifest.h>
-#include <vintf/parse_xml.h>
+#include "DebugCommand.h"
+#include "ListCommand.h"
#include "PipeRelay.h"
-#include "Timeout.h"
-
-using ::android::hardware::hidl_string;
-using ::android::hidl::manager::V1_0::IServiceManager;
namespace android {
namespace lshal {
-template <typename A>
-std::string join(const A &components, const std::string &separator) {
- std::stringstream out;
- bool first = true;
- for (const auto &component : components) {
- if (!first) {
- out << separator;
- }
- out << component;
+using ::android::hidl::manager::V1_0::IServiceManager;
- first = false;
+Lshal::Lshal()
+ : mOut(std::cout), mErr(std::cerr),
+ mServiceManager(::android::hardware::defaultServiceManager()),
+ mPassthroughManager(::android::hardware::getPassthroughServiceManager()) {
+}
+
+Lshal::Lshal(std::ostream &out, std::ostream &err,
+ sp<hidl::manager::V1_0::IServiceManager> serviceManager,
+ sp<hidl::manager::V1_0::IServiceManager> passthroughManager)
+ : mOut(out), mErr(err),
+ mServiceManager(serviceManager),
+ mPassthroughManager(passthroughManager) {
+
+}
+
+void Lshal::usage(const std::string &command) const {
+ static const std::string helpSummary =
+ "lshal: List and debug HALs.\n"
+ "\n"
+ "commands:\n"
+ " help Print help message\n"
+ " list list HALs\n"
+ " debug debug a specified HAL\n"
+ "\n"
+ "If no command is specified, `list` is the default.\n";
+
+ static const std::string list =
+ "list:\n"
+ " lshal\n"
+ " lshal list\n"
+ " List all hals with default ordering and columns (`lshal list -ipc`)\n"
+ " lshal list [-h|--help]\n"
+ " -h, --help: Print help message for list (`lshal help list`)\n"
+ " lshal [list] [--interface|-i] [--transport|-t] [-r|--arch]\n"
+ " [--pid|-p] [--address|-a] [--clients|-c] [--cmdline|-m]\n"
+ " [--sort={interface|i|pid|p}] [--init-vintf[=<output file>]]\n"
+ " [--debug|-d[=<output file>]]\n"
+ " -i, --interface: print the interface name column\n"
+ " -n, --instance: print the instance name column\n"
+ " -t, --transport: print the transport mode column\n"
+ " -r, --arch: print if the HAL is in 64-bit or 32-bit\n"
+ " -p, --pid: print the server PID, or server cmdline if -m is set\n"
+ " -a, --address: print the server object address column\n"
+ " -c, --clients: print the client PIDs, or client cmdlines if -m is set\n"
+ " -m, --cmdline: print cmdline instead of PIDs\n"
+ " -d[=<output file>], --debug[=<output file>]: emit debug info from \n"
+ " IBase::debug with empty options\n"
+ " --sort=i, --sort=interface: sort by interface name\n"
+ " --sort=p, --sort=pid: sort by server pid\n"
+ " --init-vintf=<output file>: form a skeleton HAL manifest to specified\n"
+ " file, or stdout if no file specified.\n";
+
+ static const std::string debug =
+ "debug:\n"
+ " lshal debug <interface> [options [options [...]]] \n"
+ " Print debug information of a specified interface.\n"
+ " <inteface>: Format is `android.hardware.foo@1.0::IFoo/default`.\n"
+ " If instance name is missing `default` is used.\n"
+ " options: space separated options to IBase::debug.\n";
+
+ static const std::string help =
+ "help:\n"
+ " lshal -h\n"
+ " lshal --help\n"
+ " lshal help\n"
+ " Print this help message\n"
+ " lshal help list\n"
+ " Print help message for list\n"
+ " lshal help debug\n"
+ " Print help message for debug\n";
+
+ if (command == "list") {
+ mErr << list;
+ return;
}
- return out.str();
-}
-
-static std::string toHexString(uint64_t t) {
- std::ostringstream os;
- os << std::hex << std::setfill('0') << std::setw(16) << t;
- return os.str();
-}
-
-template<typename String>
-static std::pair<String, String> splitFirst(const String &s, char c) {
- const char *pos = strchr(s.c_str(), c);
- if (pos == nullptr) {
- return {s, {}};
- }
- return {String(s.c_str(), pos - s.c_str()), String(pos + 1)};
-}
-
-static std::vector<std::string> split(const std::string &s, char c) {
- std::vector<std::string> components{};
- size_t startPos = 0;
- size_t matchPos;
- while ((matchPos = s.find(c, startPos)) != std::string::npos) {
- components.push_back(s.substr(startPos, matchPos - startPos));
- startPos = matchPos + 1;
+ if (command == "debug") {
+ mErr << debug;
+ return;
}
- if (startPos <= s.length()) {
- components.push_back(s.substr(startPos));
- }
- return components;
-}
-
-static void replaceAll(std::string *s, char from, char to) {
- for (size_t i = 0; i < s->size(); ++i) {
- if (s->at(i) == from) {
- s->at(i) = to;
- }
- }
-}
-
-std::string getCmdline(pid_t pid) {
- std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
- std::string cmdline;
- if (!ifs.is_open()) {
- return "";
- }
- ifs >> cmdline;
- return cmdline;
-}
-
-const std::string &Lshal::getCmdline(pid_t pid) {
- auto pair = mCmdlines.find(pid);
- if (pair != mCmdlines.end()) {
- return pair->second;
- }
- mCmdlines[pid] = ::android::lshal::getCmdline(pid);
- return mCmdlines[pid];
-}
-
-void Lshal::removeDeadProcesses(Pids *pids) {
- static const pid_t myPid = getpid();
- std::remove_if(pids->begin(), pids->end(), [this](auto pid) {
- return pid == myPid || this->getCmdline(pid).empty();
- });
-}
-
-bool Lshal::getReferencedPids(
- pid_t serverPid, std::map<uint64_t, Pids> *objects) const {
-
- std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
- if (!ifs.is_open()) {
- return false;
- }
-
- static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
-
- std::string line;
- std::smatch match;
- while(getline(ifs, line)) {
- if (!std::regex_search(line, match, prefix)) {
- // the line doesn't start with the correct prefix
- continue;
- }
- std::string ptrString = "0x" + match.str(2); // use number after c
- uint64_t ptr;
- if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
- // Should not reach here, but just be tolerant.
- mErr << "Could not parse number " << ptrString << std::endl;
- continue;
- }
- const std::string proc = " proc ";
- auto pos = line.rfind(proc);
- if (pos != std::string::npos) {
- for (const std::string &pidStr : split(line.substr(pos + proc.size()), ' ')) {
- int32_t pid;
- if (!::android::base::ParseInt(pidStr, &pid)) {
- mErr << "Could not parse number " << pidStr << std::endl;
- continue;
- }
- (*objects)[ptr].push_back(pid);
- }
- }
- }
- return true;
-}
-
-// Must process hwbinder services first, then passthrough services.
-void Lshal::forEachTable(const std::function<void(Table &)> &f) {
- f(mServicesTable);
- f(mPassthroughRefTable);
- f(mImplementationsTable);
-}
-void Lshal::forEachTable(const std::function<void(const Table &)> &f) const {
- f(mServicesTable);
- f(mPassthroughRefTable);
- f(mImplementationsTable);
-}
-
-void Lshal::postprocess() {
- forEachTable([this](Table &table) {
- if (mSortColumn) {
- std::sort(table.begin(), table.end(), mSortColumn);
- }
- for (TableEntry &entry : table) {
- entry.serverCmdline = getCmdline(entry.serverPid);
- removeDeadProcesses(&entry.clientPids);
- for (auto pid : entry.clientPids) {
- entry.clientCmdlines.push_back(this->getCmdline(pid));
- }
- }
- });
- // use a double for loop here because lshal doesn't care about efficiency.
- for (TableEntry &packageEntry : mImplementationsTable) {
- std::string packageName = packageEntry.interfaceName;
- FQName fqPackageName{packageName.substr(0, packageName.find("::"))};
- if (!fqPackageName.isValid()) {
- continue;
- }
- for (TableEntry &interfaceEntry : mPassthroughRefTable) {
- if (interfaceEntry.arch != ARCH_UNKNOWN) {
- continue;
- }
- FQName interfaceName{splitFirst(interfaceEntry.interfaceName, '/').first};
- if (!interfaceName.isValid()) {
- continue;
- }
- if (interfaceName.getPackageAndVersion() == fqPackageName) {
- interfaceEntry.arch = packageEntry.arch;
- }
- }
- }
-}
-
-void Lshal::printLine(
- const std::string &interfaceName,
- const std::string &transport,
- const std::string &arch,
- const std::string &server,
- const std::string &serverCmdline,
- const std::string &address, const std::string &clients,
- const std::string &clientCmdlines) const {
- if (mSelectedColumns & ENABLE_INTERFACE_NAME)
- mOut << std::setw(80) << interfaceName << "\t";
- if (mSelectedColumns & ENABLE_TRANSPORT)
- mOut << std::setw(10) << transport << "\t";
- if (mSelectedColumns & ENABLE_ARCH)
- mOut << std::setw(5) << arch << "\t";
- if (mSelectedColumns & ENABLE_SERVER_PID) {
- if (mEnableCmdlines) {
- mOut << std::setw(15) << serverCmdline << "\t";
- } else {
- mOut << std::setw(5) << server << "\t";
- }
- }
- if (mSelectedColumns & ENABLE_SERVER_ADDR)
- mOut << std::setw(16) << address << "\t";
- if (mSelectedColumns & ENABLE_CLIENT_PIDS) {
- if (mEnableCmdlines) {
- mOut << std::setw(0) << clientCmdlines;
- } else {
- mOut << std::setw(0) << clients;
- }
- }
- mOut << std::endl;
-}
-
-void Lshal::dumpVintf() const {
- mOut << "<!-- " << std::endl
- << " This is a skeleton device manifest. Notes: " << std::endl
- << " 1. android.hidl.*, android.frameworks.*, android.system.* are not included." << std::endl
- << " 2. If a HAL is supported in both hwbinder and passthrough transport, " << std::endl
- << " only hwbinder is shown." << std::endl
- << " 3. It is likely that HALs in passthrough transport does not have" << std::endl
- << " <interface> declared; users will have to write them by hand." << std::endl
- << " 4. sepolicy version is set to 0.0. It is recommended that the entry" << std::endl
- << " is removed from the manifest file and written by assemble_vintf" << std::endl
- << " at build time." << std::endl
- << "-->" << std::endl;
-
- vintf::HalManifest manifest;
- forEachTable([this, &manifest] (const Table &table) {
- for (const TableEntry &entry : table) {
-
- std::string fqInstanceName = entry.interfaceName;
-
- if (&table == &mImplementationsTable) {
- // Quick hack to work around *'s
- replaceAll(&fqInstanceName, '*', 'D');
- }
- auto splittedFqInstanceName = splitFirst(fqInstanceName, '/');
- FQName fqName(splittedFqInstanceName.first);
- if (!fqName.isValid()) {
- mErr << "Warning: '" << splittedFqInstanceName.first
- << "' is not a valid FQName." << std::endl;
- continue;
- }
- // Strip out system libs.
- if (fqName.inPackage("android.hidl") ||
- fqName.inPackage("android.frameworks") ||
- fqName.inPackage("android.system")) {
- continue;
- }
- std::string interfaceName =
- &table == &mImplementationsTable ? "" : fqName.name();
- std::string instanceName =
- &table == &mImplementationsTable ? "" : splittedFqInstanceName.second;
-
- vintf::Version version{fqName.getPackageMajorVersion(),
- fqName.getPackageMinorVersion()};
- vintf::Transport transport;
- vintf::Arch arch;
- if (entry.transport == "hwbinder") {
- transport = vintf::Transport::HWBINDER;
- arch = vintf::Arch::ARCH_EMPTY;
- } else if (entry.transport == "passthrough") {
- transport = vintf::Transport::PASSTHROUGH;
- switch (entry.arch) {
- case lshal::ARCH32:
- arch = vintf::Arch::ARCH_32; break;
- case lshal::ARCH64:
- arch = vintf::Arch::ARCH_64; break;
- case lshal::ARCH_BOTH:
- arch = vintf::Arch::ARCH_32_64; break;
- case lshal::ARCH_UNKNOWN: // fallthrough
- default:
- mErr << "Warning: '" << fqName.package()
- << "' doesn't have bitness info, assuming 32+64." << std::endl;
- arch = vintf::Arch::ARCH_32_64;
- }
- } else {
- mErr << "Warning: '" << entry.transport << "' is not a valid transport." << std::endl;
- continue;
- }
-
- bool done = false;
- for (vintf::ManifestHal *hal : manifest.getHals(fqName.package())) {
- if (hal->transport() != transport) {
- if (transport != vintf::Transport::PASSTHROUGH) {
- mErr << "Fatal: should not reach here. Generated result may be wrong."
- << std::endl;
- }
- done = true;
- break;
- }
- if (hal->hasVersion(version)) {
- if (&table != &mImplementationsTable) {
- hal->interfaces[interfaceName].name = interfaceName;
- hal->interfaces[interfaceName].instances.insert(instanceName);
- }
- done = true;
- break;
- }
- }
- if (done) {
- continue; // to next TableEntry
- }
- decltype(vintf::ManifestHal::interfaces) interfaces;
- if (&table != &mImplementationsTable) {
- interfaces[interfaceName].name = interfaceName;
- interfaces[interfaceName].instances.insert(instanceName);
- }
- if (!manifest.add(vintf::ManifestHal{
- .format = vintf::HalFormat::HIDL,
- .name = fqName.package(),
- .versions = {version},
- .transportArch = {transport, arch},
- .interfaces = interfaces})) {
- mErr << "Warning: cannot add hal '" << fqInstanceName << "'" << std::endl;
- }
- }
- });
- mOut << vintf::gHalManifestConverter(manifest);
-}
-
-static const std::string &getArchString(Architecture arch) {
- static const std::string sStr64 = "64";
- static const std::string sStr32 = "32";
- static const std::string sStrBoth = "32+64";
- static const std::string sStrUnknown = "";
- switch (arch) {
- case ARCH64:
- return sStr64;
- case ARCH32:
- return sStr32;
- case ARCH_BOTH:
- return sStrBoth;
- case ARCH_UNKNOWN: // fall through
- default:
- return sStrUnknown;
- }
-}
-
-static Architecture fromBaseArchitecture(::android::hidl::base::V1_0::DebugInfo::Architecture a) {
- switch (a) {
- case ::android::hidl::base::V1_0::DebugInfo::Architecture::IS_64BIT:
- return ARCH64;
- case ::android::hidl::base::V1_0::DebugInfo::Architecture::IS_32BIT:
- return ARCH32;
- case ::android::hidl::base::V1_0::DebugInfo::Architecture::UNKNOWN: // fallthrough
- default:
- return ARCH_UNKNOWN;
- }
+ mErr << helpSummary << "\n" << list << "\n" << debug << "\n" << help;
}
// A unique_ptr type using a custom deleter function.
template<typename T>
using deleted_unique_ptr = std::unique_ptr<T, std::function<void(T *)> >;
-void Lshal::emitDebugInfo(
- const sp<IServiceManager> &serviceManager,
+static hardware::hidl_vec<hardware::hidl_string> convert(const std::vector<std::string> &v) {
+ hardware::hidl_vec<hardware::hidl_string> hv;
+ hv.resize(v.size());
+ for (size_t i = 0; i < v.size(); ++i) {
+ hv[i].setToExternal(v[i].c_str(), v[i].size());
+ }
+ return hv;
+}
+
+Status Lshal::emitDebugInfo(
const std::string &interfaceName,
- const std::string &instanceName) const {
+ const std::string &instanceName,
+ const std::vector<std::string> &options,
+ std::ostream &out,
+ NullableOStream<std::ostream> err) const {
using android::hidl::base::V1_0::IBase;
- hardware::Return<sp<IBase>> retBase =
- serviceManager->get(interfaceName, instanceName);
+ hardware::Return<sp<IBase>> retBase = serviceManager()->get(interfaceName, instanceName);
- sp<IBase> base;
- if (!retBase.isOk() || (base = retBase) == nullptr) {
- // There's a small race, where a service instantiated while collecting
- // the list of services has by now terminated, so this isn't anything
- // to be concerned about.
- return;
+ if (!retBase.isOk()) {
+ std::string msg = "Cannot get " + interfaceName + "/" + instanceName + ": "
+ + retBase.description();
+ err << msg << std::endl;
+ LOG(ERROR) << msg;
+ return TRANSACTION_ERROR;
}
- PipeRelay relay(mOut.buf());
+ sp<IBase> base = retBase;
+ if (base == nullptr) {
+ std::string msg = interfaceName + "/" + instanceName + " does not exist, or "
+ + "no permission to connect.";
+ err << msg << std::endl;
+ LOG(ERROR) << msg;
+ return NO_INTERFACE;
+ }
+
+ PipeRelay relay(out);
if (relay.initCheck() != OK) {
- LOG(ERROR) << "PipeRelay::initCheck() FAILED w/ " << relay.initCheck();
- return;
+ std::string msg = "PipeRelay::initCheck() FAILED w/ " + std::to_string(relay.initCheck());
+ err << msg << std::endl;
+ LOG(ERROR) << msg;
+ return IO_ERROR;
}
deleted_unique_ptr<native_handle_t> fdHandle(
@@ -415,407 +171,40 @@
fdHandle->data[0] = relay.fd();
- hardware::hidl_vec<hardware::hidl_string> options;
- hardware::Return<void> ret = base->debug(fdHandle.get(), options);
+ hardware::Return<void> ret = base->debug(fdHandle.get(), convert(options));
if (!ret.isOk()) {
- LOG(ERROR)
- << interfaceName
- << "::debug(...) FAILED. (instance "
- << instanceName
- << ")";
- }
-}
-
-void Lshal::dumpTable() {
- mServicesTable.description =
- "All binderized services (registered services through hwservicemanager)";
- mPassthroughRefTable.description =
- "All interfaces that getService() has ever return as a passthrough interface;\n"
- "PIDs / processes shown below might be inaccurate because the process\n"
- "might have relinquished the interface or might have died.\n"
- "The Server / Server CMD column can be ignored.\n"
- "The Clients / Clients CMD column shows all process that have ever dlopen'ed \n"
- "the library and successfully fetched the passthrough implementation.";
- mImplementationsTable.description =
- "All available passthrough implementations (all -impl.so files)";
- forEachTable([this] (const Table &table) {
- mOut << table.description << std::endl;
- mOut << std::left;
- printLine("Interface", "Transport", "Arch", "Server", "Server CMD",
- "PTR", "Clients", "Clients CMD");
-
- // We're only interested in dumping debug info for already
- // instantiated services. There's little value in dumping the
- // debug info for a service we create on the fly, so we only operate
- // on the "mServicesTable".
- sp<IServiceManager> serviceManager;
- if (mEmitDebugInfo && &table == &mServicesTable) {
- serviceManager = ::android::hardware::defaultServiceManager();
- }
-
- for (const auto &entry : table) {
- printLine(entry.interfaceName,
- entry.transport,
- getArchString(entry.arch),
- entry.serverPid == NO_PID ? "N/A" : std::to_string(entry.serverPid),
- entry.serverCmdline,
- entry.serverObjectAddress == NO_PTR ? "N/A" : toHexString(entry.serverObjectAddress),
- join(entry.clientPids, " "),
- join(entry.clientCmdlines, ";"));
-
- if (serviceManager != nullptr) {
- auto pair = splitFirst(entry.interfaceName, '/');
- emitDebugInfo(serviceManager, pair.first, pair.second);
- }
- }
- mOut << std::endl;
- });
-
-}
-
-void Lshal::dump() {
- if (mVintf) {
- dumpVintf();
- if (!!mFileOutput) {
- mFileOutput.buf().close();
- delete &mFileOutput.buf();
- mFileOutput = nullptr;
- }
- mOut = std::cout;
- } else {
- dumpTable();
- }
-}
-
-void Lshal::putEntry(TableEntrySource source, TableEntry &&entry) {
- Table *table = nullptr;
- switch (source) {
- case HWSERVICEMANAGER_LIST :
- table = &mServicesTable; break;
- case PTSERVICEMANAGER_REG_CLIENT :
- table = &mPassthroughRefTable; break;
- case LIST_DLLIB :
- table = &mImplementationsTable; break;
- default:
- mErr << "Error: Unknown source of entry " << source << std::endl;
- }
- if (table) {
- table->entries.push_back(std::forward<TableEntry>(entry));
- }
-}
-
-Status Lshal::fetchAllLibraries(const sp<IServiceManager> &manager) {
- using namespace ::android::hardware;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
- std::map<std::string, TableEntry> entries;
- for (const auto &info : infos) {
- std::string interfaceName = std::string{info.interfaceName.c_str()} + "/" +
- std::string{info.instanceName.c_str()};
- entries.emplace(interfaceName, TableEntry{
- .interfaceName = interfaceName,
- .transport = "passthrough",
- .serverPid = NO_PID,
- .serverObjectAddress = NO_PTR,
- .clientPids = {},
- .arch = ARCH_UNKNOWN
- }).first->second.arch |= fromBaseArchitecture(info.arch);
- }
- for (auto &&pair : entries) {
- putEntry(LIST_DLLIB, std::move(pair.second));
- }
- });
- if (!ret.isOk()) {
- mErr << "Error: Failed to call list on getPassthroughServiceManager(): "
- << ret.description() << std::endl;
- return DUMP_ALL_LIBS_ERROR;
+ std::string msg = "debug() FAILED on " + interfaceName + "/" + instanceName + ": "
+ + ret.description();
+ err << msg << std::endl;
+ LOG(ERROR) << msg;
+ return TRANSACTION_ERROR;
}
return OK;
}
-Status Lshal::fetchPassthrough(const sp<IServiceManager> &manager) {
- using namespace ::android::hardware;
- using namespace ::android::hardware::details;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
- for (const auto &info : infos) {
- if (info.clientPids.size() <= 0) {
- continue;
- }
- putEntry(PTSERVICEMANAGER_REG_CLIENT, {
- .interfaceName =
- std::string{info.interfaceName.c_str()} + "/" +
- std::string{info.instanceName.c_str()},
- .transport = "passthrough",
- .serverPid = info.clientPids.size() == 1 ? info.clientPids[0] : NO_PID,
- .serverObjectAddress = NO_PTR,
- .clientPids = info.clientPids,
- .arch = fromBaseArchitecture(info.arch)
- });
- }
- });
- if (!ret.isOk()) {
- mErr << "Error: Failed to call debugDump on defaultServiceManager(): "
- << ret.description() << std::endl;
- return DUMP_PASSTHROUGH_ERROR;
- }
- return OK;
-}
-
-Status Lshal::fetchBinderized(const sp<IServiceManager> &manager) {
- using namespace ::std;
- using namespace ::android::hardware;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- const std::string mode = "hwbinder";
-
- hidl_vec<hidl_string> fqInstanceNames;
- // copying out for timeoutIPC
- auto listRet = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &names) {
- fqInstanceNames = names;
- });
- if (!listRet.isOk()) {
- mErr << "Error: Failed to list services for " << mode << ": "
- << listRet.description() << std::endl;
- return DUMP_BINDERIZED_ERROR;
- }
-
- Status status = OK;
- // server pid, .ptr value of binder object, child pids
- std::map<std::string, DebugInfo> allDebugInfos;
- std::map<pid_t, std::map<uint64_t, Pids>> allPids;
- for (const auto &fqInstanceName : fqInstanceNames) {
- const auto pair = splitFirst(fqInstanceName, '/');
- const auto &serviceName = pair.first;
- const auto &instanceName = pair.second;
- auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName);
- if (!getRet.isOk()) {
- mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "cannot be fetched from service manager:"
- << getRet.description() << std::endl;
- status |= DUMP_BINDERIZED_ERROR;
- continue;
- }
- sp<IBase> service = getRet;
- if (service == nullptr) {
- mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "cannot be fetched from service manager (null)";
- status |= DUMP_BINDERIZED_ERROR;
- continue;
- }
- auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &debugInfo) {
- allDebugInfos[fqInstanceName] = debugInfo;
- if (debugInfo.pid >= 0) {
- allPids[static_cast<pid_t>(debugInfo.pid)].clear();
- }
- });
- if (!debugRet.isOk()) {
- mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "debugging information cannot be retrieved:"
- << debugRet.description() << std::endl;
- status |= DUMP_BINDERIZED_ERROR;
- }
- }
- for (auto &pair : allPids) {
- pid_t serverPid = pair.first;
- if (!getReferencedPids(serverPid, &allPids[serverPid])) {
- mErr << "Warning: no information for PID " << serverPid
- << ", are you root?" << std::endl;
- status |= DUMP_BINDERIZED_ERROR;
- }
- }
- for (const auto &fqInstanceName : fqInstanceNames) {
- auto it = allDebugInfos.find(fqInstanceName);
- if (it == allDebugInfos.end()) {
- putEntry(HWSERVICEMANAGER_LIST, {
- .interfaceName = fqInstanceName,
- .transport = mode,
- .serverPid = NO_PID,
- .serverObjectAddress = NO_PTR,
- .clientPids = {},
- .arch = ARCH_UNKNOWN
- });
- continue;
- }
- const DebugInfo &info = it->second;
- putEntry(HWSERVICEMANAGER_LIST, {
- .interfaceName = fqInstanceName,
- .transport = mode,
- .serverPid = info.pid,
- .serverObjectAddress = info.ptr,
- .clientPids = info.pid == NO_PID || info.ptr == NO_PTR
- ? Pids{} : allPids[info.pid][info.ptr],
- .arch = fromBaseArchitecture(info.arch),
- });
- }
- return status;
-}
-
-Status Lshal::fetch() {
- Status status = OK;
- auto bManager = ::android::hardware::defaultServiceManager();
- if (bManager == nullptr) {
- mErr << "Failed to get defaultServiceManager()!" << std::endl;
- status |= NO_BINDERIZED_MANAGER;
- } else {
- status |= fetchBinderized(bManager);
- // Passthrough PIDs are registered to the binderized manager as well.
- status |= fetchPassthrough(bManager);
- }
-
- auto pManager = ::android::hardware::getPassthroughServiceManager();
- if (pManager == nullptr) {
- mErr << "Failed to get getPassthroughServiceManager()!" << std::endl;
- status |= NO_PASSTHROUGH_MANAGER;
- } else {
- status |= fetchAllLibraries(pManager);
- }
- return status;
-}
-
-void Lshal::usage() const {
- mErr
- << "usage: lshal" << std::endl
- << " Dump all hals with default ordering and columns [-ipc]." << std::endl
- << " lshal [--interface|-i] [--transport|-t] [-r|--arch]" << std::endl
- << " [--pid|-p] [--address|-a] [--clients|-c] [--cmdline|-m]" << std::endl
- << " [--sort={interface|i|pid|p}] [--init-vintf[=path]]" << std::endl
- << " -i, --interface: print the interface name column" << std::endl
- << " -n, --instance: print the instance name column" << std::endl
- << " -t, --transport: print the transport mode column" << std::endl
- << " -r, --arch: print if the HAL is in 64-bit or 32-bit" << std::endl
- << " -p, --pid: print the server PID, or server cmdline if -m is set" << std::endl
- << " -a, --address: print the server object address column" << std::endl
- << " -c, --clients: print the client PIDs, or client cmdlines if -m is set"
- << std::endl
- << " -m, --cmdline: print cmdline instead of PIDs" << std::endl
- << " --sort=i, --sort=interface: sort by interface name" << std::endl
- << " --sort=p, --sort=pid: sort by server pid" << std::endl
- << " --init-vintf=path: form a skeleton HAL manifest to specified file " << std::endl
- << " (stdout if no file specified)" << std::endl
- << " lshal [-h|--help]" << std::endl
- << " -h, --help: show this help information." << std::endl;
-}
-
-Status Lshal::parseArgs(int argc, char **argv) {
- static struct option longOptions[] = {
- // long options with short alternatives
- {"help", no_argument, 0, 'h' },
- {"interface", no_argument, 0, 'i' },
- {"transport", no_argument, 0, 't' },
- {"arch", no_argument, 0, 'r' },
- {"pid", no_argument, 0, 'p' },
- {"address", no_argument, 0, 'a' },
- {"clients", no_argument, 0, 'c' },
- {"cmdline", no_argument, 0, 'm' },
- {"debug", optional_argument, 0, 'd' },
-
- // long options without short alternatives
- {"sort", required_argument, 0, 's' },
- {"init-vintf",optional_argument, 0, 'v' },
- { 0, 0, 0, 0 }
- };
-
- int optionIndex;
- int c;
+Status Lshal::parseArgs(const Arg &arg) {
+ static std::set<std::string> sAllCommands{"list", "debug", "help"};
optind = 1;
- for (;;) {
- // using getopt_long in case we want to add other options in the future
- c = getopt_long(argc, argv, "hitrpacmd", longOptions, &optionIndex);
- if (c == -1) {
- break;
- }
- switch (c) {
- case 's': {
- if (strcmp(optarg, "interface") == 0 || strcmp(optarg, "i") == 0) {
- mSortColumn = TableEntry::sortByInterfaceName;
- } else if (strcmp(optarg, "pid") == 0 || strcmp(optarg, "p") == 0) {
- mSortColumn = TableEntry::sortByServerPid;
- } else {
- mErr << "Unrecognized sorting column: " << optarg << std::endl;
- usage();
- return USAGE;
- }
- break;
- }
- case 'v': {
- if (optarg) {
- mFileOutput = new std::ofstream{optarg};
- mOut = mFileOutput;
- if (!mFileOutput.buf().is_open()) {
- mErr << "Could not open file '" << optarg << "'." << std::endl;
- return IO_ERROR;
- }
- }
- mVintf = true;
- }
- case 'i': {
- mSelectedColumns |= ENABLE_INTERFACE_NAME;
- break;
- }
- case 't': {
- mSelectedColumns |= ENABLE_TRANSPORT;
- break;
- }
- case 'r': {
- mSelectedColumns |= ENABLE_ARCH;
- break;
- }
- case 'p': {
- mSelectedColumns |= ENABLE_SERVER_PID;
- break;
- }
- case 'a': {
- mSelectedColumns |= ENABLE_SERVER_ADDR;
- break;
- }
- case 'c': {
- mSelectedColumns |= ENABLE_CLIENT_PIDS;
- break;
- }
- case 'm': {
- mEnableCmdlines = true;
- break;
- }
- case 'd': {
- mEmitDebugInfo = true;
-
- if (optarg) {
- mFileOutput = new std::ofstream{optarg};
- mOut = mFileOutput;
- if (!mFileOutput.buf().is_open()) {
- mErr << "Could not open file '" << optarg << "'." << std::endl;
- return IO_ERROR;
- }
- chown(optarg, AID_SHELL, AID_SHELL);
- }
- break;
- }
- case 'h': // falls through
- default: // see unrecognized options
- usage();
- return USAGE;
- }
+ if (optind >= arg.argc) {
+ // no options at all.
+ return OK;
+ }
+ mCommand = arg.argv[optind];
+ if (sAllCommands.find(mCommand) != sAllCommands.end()) {
+ ++optind;
+ return OK; // mCommand is set correctly
}
- if (mSelectedColumns == 0) {
- mSelectedColumns = ENABLE_INTERFACE_NAME | ENABLE_SERVER_PID | ENABLE_CLIENT_PIDS;
+ if (mCommand.size() > 0 && mCommand[0] == '-') {
+ // first argument is an option, set command to "" (which is recognized as "list")
+ mCommand = "";
+ return OK;
}
- return OK;
-}
-int Lshal::main(int argc, char **argv) {
- Status status = parseArgs(argc, argv);
- if (status != OK) {
- return status;
- }
- status = fetch();
- postprocess();
- dump();
- return status;
+ mErr << arg.argv[0] << ": unrecognized option `" << arg.argv[optind] << "`" << std::endl;
+ usage();
+ return USAGE;
}
void signalHandler(int sig) {
@@ -825,10 +214,43 @@
}
}
+Status Lshal::main(const Arg &arg) {
+ // Allow SIGINT to terminate all threads.
+ signal(SIGINT, signalHandler);
+
+ Status status = parseArgs(arg);
+ if (status != OK) {
+ return status;
+ }
+ if (mCommand == "help") {
+ usage(optind < arg.argc ? arg.argv[optind] : "");
+ return USAGE;
+ }
+ // Default command is list
+ if (mCommand == "list" || mCommand == "") {
+ return ListCommand{*this}.main(mCommand, arg);
+ }
+ if (mCommand == "debug") {
+ return DebugCommand{*this}.main(mCommand, arg);
+ }
+ usage();
+ return USAGE;
+}
+
+NullableOStream<std::ostream> Lshal::err() const {
+ return mErr;
+}
+NullableOStream<std::ostream> Lshal::out() const {
+ return mOut;
+}
+
+const sp<IServiceManager> &Lshal::serviceManager() const {
+ return mServiceManager;
+}
+
+const sp<IServiceManager> &Lshal::passthroughManager() const {
+ return mPassthroughManager;
+}
+
} // namespace lshal
} // namespace android
-
-int main(int argc, char **argv) {
- signal(SIGINT, ::android::lshal::signalHandler);
- return ::android::lshal::Lshal{}.main(argc, argv);
-}
diff --git a/cmds/lshal/Lshal.h b/cmds/lshal/Lshal.h
index a21e86c..00db5d0 100644
--- a/cmds/lshal/Lshal.h
+++ b/cmds/lshal/Lshal.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2016 The Android Open Source Project
+ * Copyright (C) 2017 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.
@@ -17,94 +17,51 @@
#ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
#define FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
-#include <stdint.h>
-
-#include <fstream>
+#include <iostream>
#include <string>
-#include <vector>
+#include <android-base/macros.h>
#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <utils/StrongPointer.h>
#include "NullableOStream.h"
-#include "TableEntry.h"
+#include "utils.h"
namespace android {
namespace lshal {
-enum : unsigned int {
- OK = 0,
- USAGE = 1 << 0,
- NO_BINDERIZED_MANAGER = 1 << 1,
- NO_PASSTHROUGH_MANAGER = 1 << 2,
- DUMP_BINDERIZED_ERROR = 1 << 3,
- DUMP_PASSTHROUGH_ERROR = 1 << 4,
- DUMP_ALL_LIBS_ERROR = 1 << 5,
- IO_ERROR = 1 << 6,
-};
-using Status = unsigned int;
-
class Lshal {
public:
- int main(int argc, char **argv);
+ Lshal();
+ Lshal(std::ostream &out, std::ostream &err,
+ sp<hidl::manager::V1_0::IServiceManager> serviceManager,
+ sp<hidl::manager::V1_0::IServiceManager> passthroughManager);
+ Status main(const Arg &arg);
+ void usage(const std::string &command = "") const;
+ NullableOStream<std::ostream> err() const;
+ NullableOStream<std::ostream> out() const;
+ const sp<hidl::manager::V1_0::IServiceManager> &serviceManager() const;
+ const sp<hidl::manager::V1_0::IServiceManager> &passthroughManager() const;
+ Status emitDebugInfo(
+ const std::string &interfaceName,
+ const std::string &instanceName,
+ const std::vector<std::string> &options,
+ std::ostream &out,
+ NullableOStream<std::ostream> err) const;
private:
- Status parseArgs(int argc, char **argv);
- Status fetch();
- void postprocess();
- void dump();
- void usage() const;
- void putEntry(TableEntrySource source, TableEntry &&entry);
- Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
- Status fetchBinderized(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
- Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
- bool getReferencedPids(
- pid_t serverPid, std::map<uint64_t, Pids> *objects) const;
- void dumpTable();
- void dumpVintf() const;
- void printLine(
- const std::string &interfaceName,
- const std::string &transport,
- const std::string &arch,
- const std::string &server,
- const std::string &serverCmdline,
- const std::string &address, const std::string &clients,
- const std::string &clientCmdlines) const ;
- // Return /proc/{pid}/cmdline if it exists, else empty string.
- const std::string &getCmdline(pid_t pid);
- // Call getCmdline on all pid in pids. If it returns empty string, the process might
- // have died, and the pid is removed from pids.
- void removeDeadProcesses(Pids *pids);
- void forEachTable(const std::function<void(Table &)> &f);
- void forEachTable(const std::function<void(const Table &)> &f) const;
+ Status parseArgs(const Arg &arg);
+ std::string mCommand;
+ Arg mCmdArgs;
+ NullableOStream<std::ostream> mOut;
+ NullableOStream<std::ostream> mErr;
- void emitDebugInfo(
- const sp<hidl::manager::V1_0::IServiceManager> &serviceManager,
- const std::string &interfaceName,
- const std::string &instanceName) const;
+ sp<hidl::manager::V1_0::IServiceManager> mServiceManager;
+ sp<hidl::manager::V1_0::IServiceManager> mPassthroughManager;
- Table mServicesTable{};
- Table mPassthroughRefTable{};
- Table mImplementationsTable{};
-
- NullableOStream<std::ostream> mErr = std::cerr;
- NullableOStream<std::ostream> mOut = std::cout;
- NullableOStream<std::ofstream> mFileOutput = nullptr;
- TableEntryCompare mSortColumn = nullptr;
- TableEntrySelect mSelectedColumns = 0;
- // If true, cmdlines will be printed instead of pid.
- bool mEnableCmdlines = false;
-
- // If true, calls IBase::debug(...) on each service.
- bool mEmitDebugInfo = false;
-
- bool mVintf = false;
- // If an entry does not exist, need to ask /proc/{pid}/cmdline to get it.
- // If an entry exist but is an empty string, process might have died.
- // If an entry exist and not empty, it contains the cached content of /proc/{pid}/cmdline.
- std::map<pid_t, std::string> mCmdlines;
+ DISALLOW_COPY_AND_ASSIGN(Lshal);
};
-
} // namespace lshal
} // namespace android
diff --git a/cmds/lshal/PipeRelay.cpp b/cmds/lshal/PipeRelay.cpp
index c7b29df..54d19f6 100644
--- a/cmds/lshal/PipeRelay.cpp
+++ b/cmds/lshal/PipeRelay.cpp
@@ -70,7 +70,6 @@
mInitCheck = mThread->run("RelayThread");
}
-// static
void PipeRelay::CloseFd(int *fd) {
if (*fd >= 0) {
close(*fd);
diff --git a/cmds/lshal/main.cpp b/cmds/lshal/main.cpp
new file mode 100644
index 0000000..366c938
--- /dev/null
+++ b/cmds/lshal/main.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "Lshal.h"
+
+int main(int argc, char **argv) {
+ using namespace ::android::lshal;
+ return Lshal{}.main(Arg{argc, argv});
+}
diff --git a/cmds/lshal/test.cpp b/cmds/lshal/test.cpp
new file mode 100644
index 0000000..972d508
--- /dev/null
+++ b/cmds/lshal/test.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2017 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 "Lshal"
+#include <android-base/logging.h>
+
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <android/hardware/tests/baz/1.0/IQuux.h>
+#include <hidl/HidlTransportSupport.h>
+
+#include "Lshal.h"
+
+#define NELEMS(array) static_cast<int>(sizeof(array) / sizeof(array[0]))
+
+using namespace testing;
+
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hidl::manager::V1_0::IServiceManager;
+using ::android::hidl::manager::V1_0::IServiceNotification;
+using ::android::hardware::hidl_death_recipient;
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace baz {
+namespace V1_0 {
+namespace implementation {
+struct Quux : android::hardware::tests::baz::V1_0::IQuux {
+ ::android::hardware::Return<void> debug(const hidl_handle& hh, const hidl_vec<hidl_string>& options) override {
+ const native_handle_t *handle = hh.getNativeHandle();
+ if (handle->numFds < 1) {
+ return Void();
+ }
+ int fd = handle->data[0];
+ std::string content{descriptor};
+ for (const auto &option : options) {
+ content += "\n";
+ content += option.c_str();
+ }
+ ssize_t written = write(fd, content.c_str(), content.size());
+ if (written != (ssize_t)content.size()) {
+ LOG(WARNING) << "SERVER(Quux) debug writes " << written << " bytes < "
+ << content.size() << " bytes, errno = " << errno;
+ }
+ return Void();
+ }
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace baz
+} // namespace tests
+} // namespace hardware
+
+namespace lshal {
+
+
+class MockServiceManager : public IServiceManager {
+public:
+ template<typename T>
+ using R = ::android::hardware::Return<T>;
+ using String = const hidl_string&;
+ ~MockServiceManager() = default;
+
+#define MOCK_METHOD_CB(name) MOCK_METHOD1(name, R<void>(IServiceManager::name##_cb))
+
+ MOCK_METHOD2(get, R<sp<IBase>>(String, String));
+ MOCK_METHOD2(add, R<bool>(String, const sp<IBase>&));
+ MOCK_METHOD2(getTransport, R<IServiceManager::Transport>(String, String));
+ MOCK_METHOD_CB(list);
+ MOCK_METHOD2(listByInterface, R<void>(String, listByInterface_cb));
+ MOCK_METHOD3(registerForNotifications, R<bool>(String, String, const sp<IServiceNotification>&));
+ MOCK_METHOD_CB(debugDump);
+ MOCK_METHOD2(registerPassthroughClient, R<void>(String, String));
+ MOCK_METHOD_CB(interfaceChain);
+ MOCK_METHOD2(debug, R<void>(const hidl_handle&, const hidl_vec<hidl_string>&));
+ MOCK_METHOD_CB(interfaceDescriptor);
+ MOCK_METHOD_CB(getHashChain);
+ MOCK_METHOD0(setHalInstrumentation, R<void>());
+ MOCK_METHOD2(linkToDeath, R<bool>(const sp<hidl_death_recipient>&, uint64_t));
+ MOCK_METHOD0(ping, R<void>());
+ MOCK_METHOD_CB(getDebugInfo);
+ MOCK_METHOD0(notifySyspropsChanged, R<void>());
+ MOCK_METHOD1(unlinkToDeath, R<bool>(const sp<hidl_death_recipient>&));
+
+};
+
+class LshalTest : public ::testing::Test {
+public:
+ void SetUp() override {
+ using ::android::hardware::tests::baz::V1_0::IQuux;
+ using ::android::hardware::tests::baz::V1_0::implementation::Quux;
+
+ err.str("");
+ out.str("");
+ serviceManager = new testing::NiceMock<MockServiceManager>();
+ ON_CALL(*serviceManager, get(_, _)).WillByDefault(Invoke(
+ [](const auto &iface, const auto &inst) -> ::android::hardware::Return<sp<IBase>> {
+ if (iface == IQuux::descriptor && inst == "default")
+ return new Quux();
+ return nullptr;
+ }));
+ }
+ void TearDown() override {}
+
+ std::stringstream err;
+ std::stringstream out;
+ sp<MockServiceManager> serviceManager;
+};
+
+TEST_F(LshalTest, Debug) {
+ const char *args[] = {
+ "lshal", "debug", "android.hardware.tests.baz@1.0::IQuux/default", "foo", "bar"
+ };
+ EXPECT_EQ(0u, Lshal(out, err, serviceManager, serviceManager)
+ .main({NELEMS(args), const_cast<char **>(args)}));
+ EXPECT_THAT(out.str(), StrEq("android.hardware.tests.baz@1.0::IQuux\nfoo\nbar"));
+ EXPECT_THAT(err.str(), IsEmpty());
+}
+
+TEST_F(LshalTest, Debug2) {
+ const char *args[] = {
+ "lshal", "debug", "android.hardware.tests.baz@1.0::IQuux", "baz", "quux"
+ };
+ EXPECT_EQ(0u, Lshal(out, err, serviceManager, serviceManager)
+ .main({NELEMS(args), const_cast<char **>(args)}));
+ EXPECT_THAT(out.str(), StrEq("android.hardware.tests.baz@1.0::IQuux\nbaz\nquux"));
+ EXPECT_THAT(err.str(), IsEmpty());
+}
+
+TEST_F(LshalTest, Debug3) {
+ const char *args[] = {
+ "lshal", "debug", "android.hardware.tests.doesnotexist@1.0::IDoesNotExist",
+ };
+ EXPECT_NE(0u, Lshal(out, err, serviceManager, serviceManager)
+ .main({NELEMS(args), const_cast<char **>(args)}));
+ EXPECT_THAT(err.str(), HasSubstr("does not exist"));
+}
+
+} // namespace lshal
+} // namespace android
+
+int main(int argc, char **argv) {
+ ::testing::InitGoogleMock(&argc, argv);
+ return RUN_ALL_TESTS();
+}
diff --git a/cmds/lshal/utils.cpp b/cmds/lshal/utils.cpp
new file mode 100644
index 0000000..5550721
--- /dev/null
+++ b/cmds/lshal/utils.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "utils.h"
+
+namespace android {
+namespace lshal {
+
+std::string toHexString(uint64_t t) {
+ std::ostringstream os;
+ os << std::hex << std::setfill('0') << std::setw(16) << t;
+ return os.str();
+}
+
+std::vector<std::string> split(const std::string &s, char c) {
+ std::vector<std::string> components{};
+ size_t startPos = 0;
+ size_t matchPos;
+ while ((matchPos = s.find(c, startPos)) != std::string::npos) {
+ components.push_back(s.substr(startPos, matchPos - startPos));
+ startPos = matchPos + 1;
+ }
+
+ if (startPos <= s.length()) {
+ components.push_back(s.substr(startPos));
+ }
+ return components;
+}
+
+void replaceAll(std::string *s, char from, char to) {
+ for (size_t i = 0; i < s->size(); ++i) {
+ if (s->at(i) == from) {
+ s->at(i) = to;
+ }
+ }
+}
+
+} // namespace lshal
+} // namespace android
+
diff --git a/cmds/lshal/utils.h b/cmds/lshal/utils.h
new file mode 100644
index 0000000..45b922c
--- /dev/null
+++ b/cmds/lshal/utils.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_UTILS_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_UTILS_H_
+
+#include <iomanip>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+namespace android {
+namespace lshal {
+
+enum : unsigned int {
+ OK = 0,
+ USAGE = 1 << 0,
+ NO_BINDERIZED_MANAGER = 1 << 1,
+ NO_PASSTHROUGH_MANAGER = 1 << 2,
+ DUMP_BINDERIZED_ERROR = 1 << 3,
+ DUMP_PASSTHROUGH_ERROR = 1 << 4,
+ DUMP_ALL_LIBS_ERROR = 1 << 5,
+ IO_ERROR = 1 << 6,
+ NO_INTERFACE = 1 << 7,
+ TRANSACTION_ERROR = 1 << 8,
+};
+using Status = unsigned int;
+
+struct Arg {
+ int argc;
+ char **argv;
+};
+
+template <typename A>
+std::string join(const A &components, const std::string &separator) {
+ std::stringstream out;
+ bool first = true;
+ for (const auto &component : components) {
+ if (!first) {
+ out << separator;
+ }
+ out << component;
+
+ first = false;
+ }
+ return out.str();
+}
+
+std::string toHexString(uint64_t t);
+
+template<typename String>
+std::pair<String, String> splitFirst(const String &s, char c) {
+ const char *pos = strchr(s.c_str(), c);
+ if (pos == nullptr) {
+ return {s, {}};
+ }
+ return {String(s.c_str(), pos - s.c_str()), String(pos + 1)};
+}
+
+std::vector<std::string> split(const std::string &s, char c);
+
+void replaceAll(std::string *s, char from, char to);
+
+} // namespace lshal
+} // namespace android
+
+#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_UTILS_H_
diff --git a/libs/nativewindow/AHardwareBuffer.cpp b/libs/nativewindow/AHardwareBuffer.cpp
index 80c5ec2..c0602e7 100644
--- a/libs/nativewindow/AHardwareBuffer.cpp
+++ b/libs/nativewindow/AHardwareBuffer.cpp
@@ -179,12 +179,17 @@
memcpy(fdData, fds.get(), sizeof(int) * fdCount);
msg.msg_controllen = cmsg->cmsg_len;
- int result = sendmsg(socketFd, &msg, 0);
- if (result <= 0) {
+ int result;
+ do {
+ result = sendmsg(socketFd, &msg, 0);
+ } while (result == -1 && errno == EINTR);
+ if (result == -1) {
+ result = errno;
ALOGE("Error writing AHardwareBuffer to socket: error %#x (%s)",
- result, strerror(errno));
- return result;
+ result, strerror(result));
+ return -result;
}
+
return NO_ERROR;
}
@@ -206,11 +211,15 @@
.msg_iovlen = 1,
};
- int result = recvmsg(socketFd, &msg, 0);
- if (result <= 0) {
+ int result;
+ do {
+ result = recvmsg(socketFd, &msg, 0);
+ } while (result == -1 && errno == EINTR);
+ if (result == -1) {
+ result = errno;
ALOGE("Error reading AHardwareBuffer from socket: error %#x (%s)",
- result, strerror(errno));
- return result;
+ result, strerror(result));
+ return -result;
}
if (msg.msg_iovlen != 1) {
diff --git a/libs/ui/Fence.cpp b/libs/ui/Fence.cpp
index 02d4137..b67f4d9 100644
--- a/libs/ui/Fence.cpp
+++ b/libs/ui/Fence.cpp
@@ -165,7 +165,7 @@
return INVALID_OPERATION;
}
- if (size < 1) {
+ if (size < getFlattenedSize()) {
return NO_MEMORY;
}
diff --git a/libs/ui/GraphicsEnv.cpp b/libs/ui/GraphicsEnv.cpp
index 1d20424..8182c07 100644
--- a/libs/ui/GraphicsEnv.cpp
+++ b/libs/ui/GraphicsEnv.cpp
@@ -23,6 +23,11 @@
#include <log/log.h>
#include <nativeloader/dlext_namespaces.h>
+// TODO(b/37049319) Get this from a header once one exists
+extern "C" {
+ android_namespace_t* android_get_exported_namespace(const char*);
+}
+
namespace android {
/*static*/ GraphicsEnv& GraphicsEnv::getInstance() {
@@ -43,33 +48,19 @@
android_namespace_t* GraphicsEnv::getDriverNamespace() {
static std::once_flag once;
std::call_once(once, [this]() {
- // TODO; In the next version of Android, all graphics drivers will be
- // loaded into a custom namespace. To minimize risk for this release,
- // only updated drivers use a custom namespace.
- //
- // Additionally, the custom namespace will be
- // ANDROID_NAMESPACE_TYPE_ISOLATED, and will only have access to a
- // subset of the system.
if (mDriverPath.empty())
return;
-
- char defaultPath[PATH_MAX];
- android_get_LD_LIBRARY_PATH(defaultPath, sizeof(defaultPath));
- size_t defaultPathLen = strlen(defaultPath);
-
- std::string path;
- path.reserve(mDriverPath.size() + 1 + defaultPathLen);
- path.append(mDriverPath);
- path.push_back(':');
- path.append(defaultPath, defaultPathLen);
-
- mDriverNamespace = android_create_namespace(
- "gfx driver",
- nullptr, // ld_library_path
- path.c_str(), // default_library_path
- ANDROID_NAMESPACE_TYPE_SHARED,
- nullptr, // permitted_when_isolated_path
- nullptr); // parent
+ // If the sphal namespace isn't configured for a device, don't support updatable drivers.
+ // We need a parent namespace to inherit the default search path from.
+ auto sphalNamespace = android_get_exported_namespace("sphal");
+ if (!sphalNamespace) return;
+ mDriverNamespace = android_create_namespace("gfx driver",
+ nullptr, // ld_library_path
+ mDriverPath.c_str(), // default_library_path
+ ANDROID_NAMESPACE_TYPE_SHARED |
+ ANDROID_NAMESPACE_TYPE_ISOLATED,
+ nullptr, // permitted_when_isolated_path
+ sphalNamespace);
});
return mDriverNamespace;
}
diff --git a/libs/vr/libposepredictor/Android.bp b/libs/vr/libposepredictor/Android.bp
deleted file mode 100644
index 2f1d2f5..0000000
--- a/libs/vr/libposepredictor/Android.bp
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (C) 2008 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.
-
-sourceFiles = [
- "predictor.cpp",
- "buffered_predictor.cpp",
- "linear_predictor.cpp",
- "polynomial_predictor.cpp",
- "dvr_pose_predictor.cpp",
-]
-
-includeFiles = [
- "include",
-]
-
-staticLibraries = ["libvrsensor"]
-
-sharedLibraries = []
-
-headerLibraries = [ "libeigen" ]
-
-cc_library {
- srcs: sourceFiles,
- cflags: [
- "-DLOG_TAG=\"libposepredictor\"",
- "-DTRACE=0",
- ],
- export_include_dirs: includeFiles,
- static_libs: staticLibraries,
- shared_libs: sharedLibraries,
- header_libs: headerLibraries,
- export_header_lib_headers: headerLibraries,
- name: "libposepredictor",
-}
-
-cc_test {
- tags: ["optional"],
- srcs: [
- "predictor_tests.cpp",
- "linear_predictor_tests.cpp",
- "polynomial_predictor_tests.cpp",
- ],
-
- static_libs: ["libposepredictor"] + staticLibraries,
- shared_libs: sharedLibraries,
- name: "pose_predictor_tests",
-}
diff --git a/libs/vr/libposepredictor/buffered_predictor.cpp b/libs/vr/libposepredictor/buffered_predictor.cpp
deleted file mode 100644
index f3b41dc..0000000
--- a/libs/vr/libposepredictor/buffered_predictor.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <buffered_predictor.h>
-
-namespace posepredictor {
-
-BufferedPredictor::BufferedPredictor(size_t buffer_size) {
- buffer_.resize(buffer_size);
-}
-
-void BufferedPredictor::BufferSample(const Pose& sample) {
- const auto& prev_sample = buffer_[current_pose_index_];
-
- // If we are updating a sample (the same time stamp), do not advance the
- // counter.
- if (sample.time_ns != prev_sample.time_ns) {
- current_pose_index_ = (current_pose_index_ + 1) % buffer_.size();
- }
-
- buffer_[current_pose_index_] = sample;
-
- // Make sure the subsequent orientations are the closest in quaternion space.
- if (PrevSample(1).orientation.coeffs().dot(sample.orientation.coeffs()) < 0) {
- // Flip the quaternion to be closest to the previous sample.
- buffer_[current_pose_index_].orientation =
- quat(-sample.orientation.w(), -sample.orientation.x(),
- -sample.orientation.y(), -sample.orientation.z());
- }
-
- ++num_poses_added_;
-}
-
-const Pose& BufferedPredictor::PrevSample(size_t index) const {
- // We must not request a pose too far in the past.
- assert(index < buffer_.size());
- return buffer_[(current_pose_index_ - index + buffer_.size()) %
- buffer_.size()];
-}
-
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/dvr_pose_predictor.cpp b/libs/vr/libposepredictor/dvr_pose_predictor.cpp
deleted file mode 100644
index 7f2ecc0..0000000
--- a/libs/vr/libposepredictor/dvr_pose_predictor.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <private/dvr/dvr_pose_predictor.h>
-
-namespace android {
-namespace dvr {
-
-namespace {
-template <typename Vec3Type>
-float32x4_t FromVec3(const Vec3Type& from) {
- return {static_cast<float>(from.x()), static_cast<float>(from.y()),
- static_cast<float>(from.z()), 0};
-}
-
-template <typename QuatType>
-float32x4_t FromQuat(const QuatType& from) {
- return {static_cast<float>(from.x()), static_cast<float>(from.y()),
- static_cast<float>(from.z()), static_cast<float>(from.w())};
-}
-
-} // namespace
-
-void AddPredictorPose(posepredictor::Predictor* predictor,
- const posepredictor::vec3& start_t_head,
- const posepredictor::quat& start_q_head,
- int64_t pose_timestamp, DvrPoseAsync* out) {
- // Feed the predictor.
- predictor->Add(
- posepredictor::Pose{pose_timestamp, start_t_head, start_q_head});
-
- // Fill the output.
- out->timestamp_ns = pose_timestamp;
-
- out->translation = FromVec3(start_t_head);
- out->orientation = FromQuat(start_q_head);
-
- out->right_translation = out->translation;
- out->right_orientation = out->orientation;
-
- const auto velocity = predictor->PredictVelocity(pose_timestamp);
-
- out->velocity = FromVec3(velocity.linear);
- out->angular_velocity = FromVec3(velocity.angular);
-
- out->flags = DVR_POSE_FLAG_HEAD | DVR_POSE_FLAG_VALID;
- memset(out->pad, 0, sizeof(out->pad));
-}
-
-void PredictPose(const posepredictor::Predictor* predictor, int64_t left_ns,
- int64_t right_ns, DvrPoseAsync* out) {
- const auto left_pose = predictor->Predict(left_ns);
- const auto right_pose = predictor->Predict(right_ns);
- const auto velocity = predictor->PredictVelocity((left_ns + right_ns) / 2);
-
- // Fill the output.
- out->timestamp_ns = left_ns;
-
- out->translation = FromVec3(left_pose.position);
- out->orientation = FromQuat(left_pose.orientation);
-
- out->right_translation = FromVec3(right_pose.position);
- out->right_orientation = FromQuat(right_pose.orientation);
-
- out->velocity = FromVec3(velocity.linear);
- out->angular_velocity = FromVec3(velocity.angular);
-
- out->flags = DVR_POSE_FLAG_HEAD | DVR_POSE_FLAG_VALID;
- memset(out->pad, 0, sizeof(out->pad));
-}
-
-} // dvr
-} // android
diff --git a/libs/vr/libposepredictor/include/buffered_predictor.h b/libs/vr/libposepredictor/include/buffered_predictor.h
deleted file mode 100644
index eab0150..0000000
--- a/libs/vr/libposepredictor/include/buffered_predictor.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef POSEPREDICTOR_BUFFERED_PREDICTOR_H_
-#define POSEPREDICTOR_BUFFERED_PREDICTOR_H_
-
-#include <vector>
-
-#include "predictor.h"
-
-namespace posepredictor {
-
-// Keeps the previous n poses around in a ring buffer.
-// The orientations are also unrolled so that a . b > 0 for two subsequent
-// quaternions a and b.
-class BufferedPredictor : public Predictor {
- public:
- BufferedPredictor(size_t buffer_size);
- ~BufferedPredictor() = default;
-
- protected:
- // Add a pose sample into the buffer.
- void BufferSample(const Pose& sample);
-
- // Grab a previous sample.
- // index = 0: last sample
- // index = 1: the one before that
- // ...
- const Pose& PrevSample(size_t index) const;
-
- // Where we keep the last n poses.
- std::vector<Pose> buffer_;
-
- // Where the last valid pose is in the buffer.
- size_t current_pose_index_ = 0;
-
- // The number of poses we have added.
- size_t num_poses_added_ = 0;
-};
-
-} // namespace posepredictor
-
-#endif // POSEPREDICTOR_BUFFERED_PREDICTOR_H_
diff --git a/libs/vr/libposepredictor/include/linear_predictor.h b/libs/vr/libposepredictor/include/linear_predictor.h
deleted file mode 100644
index 0d17ec5..0000000
--- a/libs/vr/libposepredictor/include/linear_predictor.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef POSEPREDICTOR_LINEAR_POSE_PREDICTOR_H_
-#define POSEPREDICTOR_LINEAR_POSE_PREDICTOR_H_
-
-#include "predictor.h"
-
-namespace posepredictor {
-
-// This class makes a linear prediction using the last two samples we received.
-class LinearPosePredictor : public Predictor {
- public:
- LinearPosePredictor() = default;
-
- // Add a new sample.
- void Add(const Pose& sample) override;
-
- // Predict using the last two samples.
- Pose Predict(int64_t time_ns) const override;
-
- // Just copy the velocity over.
- Velocity PredictVelocity(int64_t time_ns) const override;
-
- private:
- // The index of the last sample we received.
- size_t current_index_ = 0;
-
- // The previous two samples.
- Pose samples_[2];
-
- // Experimental
- bool forward_predict_angular_speed_ = false;
-
- // Transient variables updated when a sample is added.
- vec3 velocity_ = vec3::Zero();
- vec3 rotational_velocity_ = vec3::Zero();
- vec3 rotational_axis_ = vec3::Zero();
- real last_angular_speed_ = 0;
- real angular_speed_ = 0;
- real angular_accel_ = 0;
-};
-
-} // namespace posepredictor
-
-#endif // POSEPREDICTOR_LINEAR_POSE_PREDICTOR_H_
diff --git a/libs/vr/libposepredictor/include/polynomial_predictor.h b/libs/vr/libposepredictor/include/polynomial_predictor.h
deleted file mode 100644
index 4b8d51b..0000000
--- a/libs/vr/libposepredictor/include/polynomial_predictor.h
+++ /dev/null
@@ -1,168 +0,0 @@
-#ifndef POSEPREDICTOR_POLYNOMIAL_POSE_PREDICTOR_H_
-#define POSEPREDICTOR_POLYNOMIAL_POSE_PREDICTOR_H_
-
-#include <vector>
-
-#include <Eigen/Dense>
-
-#include "buffered_predictor.h"
-
-namespace posepredictor {
-
-// Make a polynomial prediction of the form
-// y = coefficients_[0] + coefficients_[1] * t + coefficients_[2] * t^2 + ...
-// where t is time and y is the position and orientation.
-// We recompute the coefficients whenever we add a new sample using
-// training_window previous samples.
-template <size_t PolynomialDegree, size_t TrainingWindow>
-class PolynomialPosePredictor : public BufferedPredictor {
- public:
- PolynomialPosePredictor(real regularization = 1e-9)
- : BufferedPredictor(TrainingWindow), regularization_(regularization) {
- static_assert(TrainingWindow >= PolynomialDegree + 1,
- "Underconstrained polynomial regressor");
- }
-
- ~PolynomialPosePredictor() = default;
-
- // We convert pose samples into a vector for matrix arithmetic using this
- // mapping.
- enum Components {
- kPositionX = 0,
- kPositionY,
- kPositionZ,
- kOrientationX,
- kOrientationY,
- kOrientationZ,
- kOrientationW,
- kNumComponents
- };
-
- // Add a new sample.
- void Add(const Pose& sample) override {
- // Add the sample to the ring buffer.
- BufferedPredictor::BufferSample(sample);
-
- Eigen::Matrix<real, TrainingWindow, kNumComponents> values;
-
- // Get the pose samples into matrices for fitting.
- real t_vector[TrainingWindow];
- for (size_t i = 0; i < TrainingWindow; ++i) {
- const auto& prev_sample = PrevSample(i);
-
- t_vector[i] = NsToT(prev_sample.time_ns);
-
- // Save the values we will be fitting to at each sample time.
- values(i, kPositionX) = prev_sample.position.x();
- values(i, kPositionY) = prev_sample.position.y();
- values(i, kPositionZ) = prev_sample.position.z();
- values(i, kOrientationX) = prev_sample.orientation.x();
- values(i, kOrientationY) = prev_sample.orientation.y();
- values(i, kOrientationZ) = prev_sample.orientation.z();
- values(i, kOrientationW) = prev_sample.orientation.w();
- }
-
- // Some transient matrices for solving for coefficient matrix.
- Eigen::Matrix<real, PolynomialDegree + 1, PolynomialDegree + 1> M;
- Eigen::Matrix<real, PolynomialDegree + 1, 1> d;
- Eigen::Matrix<real, PolynomialDegree + 1, 1> p;
-
- // Create a polynomial fit for each component.
- for (size_t component = 0; component < kNumComponents; ++component) {
- // A = [ 1 t t^2 ... ]'
- // x = [ coefficients[0] coefficients[1] .... ]'
- // b = [ position.x ]'
- // We would like to solve A' x + regularization * I = b'
- // given the samples we have in our training window.
- //
- // The loop below will compute:
- // M = A' * A
- // d = A' * b
- // so we can solve M * coefficients + regularization * I = b
-
- M.setIdentity();
- d.setZero();
- p[0] = 1;
-
- // M = regularization * I
- M = M * regularization_;
-
- // Accumulate the poses in the training window.
- for (size_t i = 0; i < TrainingWindow; ++i) {
- // Compute the polynomial at this sample.
- for (size_t j = 1; j <= PolynomialDegree; ++j) {
- p[j] = p[j - 1] * t_vector[i];
- }
-
- // Accumulate the left and right hand sides.
- M = M + p * p.transpose();
- d = d + p * values(i, component);
- }
-
- // M is symmetric, positive semi-definite.
- // Note: This is not the most accurate solver out there but is fast.
- coefficients_.row(component) = Eigen::LLT<Eigen::MatrixXd>(M).solve(d);
- }
- }
-
- // Predict using the polynomial coefficients.
- Pose Predict(int64_t time_ns) const override {
- // Predict the left side.
- const auto components = SamplePolynomial(time_ns);
-
- return {time_ns,
- vec3(components[kPositionX], components[kPositionY],
- components[kPositionZ]),
- quat(components[kOrientationW], components[kOrientationX],
- components[kOrientationY], components[kOrientationZ])
- .normalized()};
- }
-
- private:
- // Evaluate the polynomial at a particular time.
- Eigen::Matrix<real, kNumComponents, 1> SamplePolynomial(
- int64_t time_ns) const {
- const auto t = NsToT(time_ns);
- Eigen::Matrix<real, PolynomialDegree + 1, 1> polynomial;
- real current_polynomial = t;
-
- // Compute polynomial = [ 1 t t^2 ... ]
- polynomial[0] = 1;
- for (size_t degree = 1; degree <= PolynomialDegree;
- ++degree, current_polynomial *= t) {
- polynomial[degree] = polynomial[degree - 1] * t;
- }
-
- // The coefficients_ = [ numComponents x (polynomial degree + 1) ].
- return coefficients_ * polynomial;
- }
-
- // Convert a time in nanoseconds to t.
- // We could use the seconds as t but this would create make it more difficult
- // to tweak the regularization amount. So we subtract the last sample time so
- // the scale of the regularization constant doesn't change as a function of
- // time.
- real NsToT(int64_t time_ns) const {
- return NsToSeconds(time_ns - buffer_[current_pose_index_].time_ns);
- }
-
- // The ridge regularization constant.
- real regularization_;
-
- // This is where we store the polynomial coefficients.
- Eigen::Matrix<real, kNumComponents, PolynomialDegree + 1> coefficients_;
-};
-
-// Some common polynomial types.
-extern template class PolynomialPosePredictor<1, 2>;
-extern template class PolynomialPosePredictor<2, 3>;
-extern template class PolynomialPosePredictor<3, 4>;
-extern template class PolynomialPosePredictor<4, 5>;
-
-using QuadricPosePredictor = PolynomialPosePredictor<2, 3>;
-using CubicPosePredictor = PolynomialPosePredictor<3, 4>;
-using QuarticPosePredictor = PolynomialPosePredictor<4, 5>;
-
-} // namespace posepredictor
-
-#endif // POSEPREDICTOR_POLYNOMIAL_POSE_PREDICTOR_H_
diff --git a/libs/vr/libposepredictor/include/predictor.h b/libs/vr/libposepredictor/include/predictor.h
deleted file mode 100644
index 78db272..0000000
--- a/libs/vr/libposepredictor/include/predictor.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef POSEPREDICTOR_POSE_PREDICTOR_H_
-#define POSEPREDICTOR_POSE_PREDICTOR_H_
-
-#include <Eigen/Core>
-#include <Eigen/Geometry>
-
-// This is the only file you need to include for pose prediction.
-
-namespace posepredictor {
-
-// The precision for the predictor.
-// TODO(okana): double precision is probably not necessary.
-typedef double real;
-
-using vec3 = Eigen::Matrix<real, 3, 1>;
-using quat = Eigen::Quaternion<real>;
-
-// Encapsulates a pose sample.
-struct Pose {
- int64_t time_ns = 0;
- vec3 position = vec3::Zero();
- quat orientation = quat::Identity();
-};
-
-// Encapsulates the derivative at a time.
-struct Velocity {
- vec3 linear = vec3::Zero();
- vec3 angular = vec3::Zero();
-};
-
-// The preset types we support.
-enum class PredictorType { Linear, Quadric, Cubic };
-
-// This is an abstract base class for prediction 6dof pose given
-// a set of samples.
-class Predictor {
- public:
- Predictor() = default;
- virtual ~Predictor() = default;
-
- // The nanoseconds to use for finite differencing.
- static constexpr int64_t kFiniteDifferenceNs = 100;
-
- // Instantiate a new pose predictor for a type.
- static std::unique_ptr<Predictor> Create(PredictorType type);
-
- // Compute the angular velocity from orientation start_orientation to
- // end_orientation in delta_time.
- static vec3 AngularVelocity(const quat& start_orientation,
- const quat& end_orientation, real delta_time);
-
- // Add a pose sample coming from the sensors.
- virtual void Add(const Pose& sample) = 0;
-
- // Make a pose prediction for at specific time.
- virtual Pose Predict(int64_t time_ns) const = 0;
-
- // Evaluate velocity at a particular time.
- // The default implementation uses finite differencing.
- virtual Velocity PredictVelocity(int64_t time_ns) const;
-
- // Helpers
- static real NsToSeconds(int64_t time_ns) {
- return static_cast<real>(time_ns / 1e9);
- }
- static int64_t SecondsToNs(real seconds) {
- return static_cast<int64_t>(seconds * 1e9);
- }
-};
-
-} // namespace posepredictor
-
-#endif // POSEPREDICTOR_POSE_PREDICTOR_H_
diff --git a/libs/vr/libposepredictor/include/private/dvr/dvr_pose_predictor.h b/libs/vr/libposepredictor/include/private/dvr/dvr_pose_predictor.h
deleted file mode 100644
index bd2dcbc..0000000
--- a/libs/vr/libposepredictor/include/private/dvr/dvr_pose_predictor.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef ANDROID_DVR_POSE_PREDICTOR_H_
-#define ANDROID_DVR_POSE_PREDICTOR_H_
-
-#include <dvr/pose_client.h>
-#include <predictor.h>
-
-// Some shim functions for connecting dvr to pose predictor.
-
-namespace android {
-namespace dvr {
-
-// Feed a pose to the predictor.
-void AddPredictorPose(posepredictor::Predictor* predictor,
- const posepredictor::vec3& start_t_head,
- const posepredictor::quat& start_q_head,
- int64_t pose_timestamp, DvrPoseAsync* out);
-
-// Make a prediction for left and right eyes.
-void PredictPose(const posepredictor::Predictor* predictor, int64_t left_ns,
- int64_t right_ns, DvrPoseAsync* out);
-
-} // namespace dvr
-} // namespace android
-
-#endif // ANDROID_DVR_POSE_PREDICTOR_H_
diff --git a/libs/vr/libposepredictor/linear_predictor.cpp b/libs/vr/libposepredictor/linear_predictor.cpp
deleted file mode 100644
index 6f924dc..0000000
--- a/libs/vr/libposepredictor/linear_predictor.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <linear_predictor.h>
-
-namespace posepredictor {
-
-using AngleAxis = Eigen::AngleAxis<real>;
-
-void LinearPosePredictor::Add(const Pose& sample) {
- // If we are receiving a new sample, move the index to the next item.
- // If the time stamp is the same as the last frame, we will just overwrite
- // it with the new data.
- if (sample.time_ns != samples_[current_index_].time_ns) {
- current_index_ ^= 1;
- }
-
- // Save the sample.
- samples_[current_index_] = sample;
-
- // The previous sample we received.
- const auto& previous_sample = samples_[current_index_ ^ 1];
-
- // Ready to compute velocities.
- const auto pose_delta_time =
- NsToSeconds(sample.time_ns - previous_sample.time_ns);
-
- if (pose_delta_time > 0.0) {
- velocity_ = (sample.position - previous_sample.position) / pose_delta_time;
- rotational_velocity_ = Predictor::AngularVelocity(
- previous_sample.orientation, sample.orientation, pose_delta_time);
- } else {
- velocity_ = vec3::Zero();
- rotational_velocity_ = vec3::Zero();
- }
-
- // Temporary experiment with acceleration estimate.
- angular_speed_ = rotational_velocity_.norm();
- angular_accel_ = 0.0;
- if (forward_predict_angular_speed_) {
- angular_accel_ =
- pose_delta_time > 0.0
- ? (angular_speed_ - last_angular_speed_) / pose_delta_time
- : 0.0;
- }
- last_angular_speed_ = angular_speed_;
-
- rotational_axis_ = vec3(0.0, 1.0, 0.0);
- if (angular_speed_ > 0.0) {
- rotational_axis_ = rotational_velocity_ / angular_speed_;
- }
-}
-
-Pose LinearPosePredictor::Predict(int64_t time_ns) const {
- const auto& sample = samples_[current_index_];
-
- const auto dt = NsToSeconds(time_ns - sample.time_ns);
-
- // Temporary forward prediction code.
- auto angle = angular_speed_ * dt;
- if (__builtin_expect(forward_predict_angular_speed_, 0)) {
- angle += 0.5 * angular_accel_ * dt * dt;
- }
-
- return {time_ns, sample.position + velocity_ * dt,
- sample.orientation * quat(AngleAxis(angle, rotational_axis_))};
-}
-
-Velocity LinearPosePredictor::PredictVelocity(int64_t /* time_ns */) const {
- return {velocity_, rotational_velocity_};
-}
-
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/linear_predictor_tests.cpp b/libs/vr/libposepredictor/linear_predictor_tests.cpp
deleted file mode 100644
index d94aa2d..0000000
--- a/libs/vr/libposepredictor/linear_predictor_tests.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <linear_predictor.h>
-
-namespace posepredictor {
-
-namespace {
-
-// For comparing expected and actual.
-constexpr real kAbsErrorTolerance = 1e-5;
-
-// The default rotation axis we will be using.
-const vec3 kRotationAxis = vec3(1, 4, 3).normalized();
-
-// Linearly interpolate between a and b.
-vec3 lerp(const vec3& a, const vec3& b, real t) { return (b - a) * t + a; }
-
-// Linearly interpolate between two angles and return the resulting rotation as
-// a quaternion (around the kRotationAxis).
-quat qlerp(real angle1, real angle2, real t) {
- return quat(
- Eigen::AngleAxis<real>((angle2 - angle1) * t + angle1, kRotationAxis));
-}
-
-// Compare two positions.
-void TestPosition(const vec3& expected, const vec3& actual) {
- for (int i = 0; i < 3; ++i) {
- EXPECT_NEAR(expected[i], actual[i], kAbsErrorTolerance);
- }
-}
-
-// Compare two orientations.
-void TestOrientation(const quat& expected, const quat& actual) {
- // abs(expected.dot(actual)) > 1-eps
- EXPECT_GE(std::abs(actual.coeffs().dot(expected.coeffs())), 0.99);
-}
-}
-
-// Test the extrapolation from two samples.
-TEST(LinearPosePredictorTest, Extrapolation) {
- LinearPosePredictor predictor;
-
- // We wil extrapolate linearly from [position|orientation] 1 -> 2.
- const vec3 position1(0, 0, 0);
- const vec3 position2(1, 2, 3);
- const real angle1 = M_PI * 0.3;
- const real angle2 = M_PI * 0.5;
- const quat orientation1(Eigen::AngleAxis<real>(angle1, kRotationAxis));
- const quat orientation2(Eigen::AngleAxis<real>(angle2, kRotationAxis));
- const int64_t t1_ns = 0; //< First sample time stamp
- const int64_t t2_ns = 10; //< The second sample time stamp
- const int64_t eval_left_ns = 23; //< The eval time for left
- const int64_t eval_right_ns = 31; //< The eval time for right
- Pose start_pose, end_pose, extrapolated_pose;
-
- predictor.Add(Pose{
- .position = position1, .orientation = orientation1, .time_ns = t1_ns});
-
- predictor.Add(Pose{
- .position = position2, .orientation = orientation2, .time_ns = t2_ns});
-
- // Extrapolate from t1 - t2 to eval_[left/right].
- extrapolated_pose = predictor.Predict(eval_left_ns);
-
- // The interpolation factors for left and right.
- const auto left_t = (eval_left_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
- EXPECT_EQ(2.3, left_t);
-
- TestPosition(lerp(position1, position2, left_t), extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle2, left_t), extrapolated_pose.orientation);
-
- extrapolated_pose = predictor.Predict(eval_right_ns);
-
- const auto right_t =
- (eval_right_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
- EXPECT_EQ(3.1, right_t);
-
- TestPosition(lerp(position1, position2, right_t), extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle2, right_t),
- extrapolated_pose.orientation);
-}
-
-// Test three samples, where the last two samples have the same timestamp.
-TEST(LinearPosePredictorTest, DuplicateSamples) {
- LinearPosePredictor predictor;
-
- const vec3 position1(0, 0, 0);
- const vec3 position2(1, 2, 3);
- const vec3 position3(2, 2, 3);
- const real angle1 = M_PI * 0.3;
- const real angle2 = M_PI * 0.5;
- const real angle3 = M_PI * 0.65;
- const quat orientation1(Eigen::AngleAxis<real>(angle1, kRotationAxis));
- const quat orientation2(Eigen::AngleAxis<real>(angle2, kRotationAxis));
- const quat orientation3(Eigen::AngleAxis<real>(angle3, kRotationAxis));
- const int64_t t1_ns = 0;
- const int64_t t2_ns = 10;
- const int64_t eval_left_ns = 27;
- const int64_t eval_right_ns = 31;
- Pose extrapolated_pose;
-
- predictor.Add(Pose{
- .position = position1, .orientation = orientation1, .time_ns = t1_ns});
-
- predictor.Add(Pose{
- .position = position2, .orientation = orientation2, .time_ns = t2_ns});
-
- {
- // Extrapolate from t1 - t2 to eval_[left/right].
- extrapolated_pose = predictor.Predict(eval_left_ns);
-
- // The interpolation factors for left and right.
- const auto left_t =
- (eval_left_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
-
- // Test the result.
- TestPosition(lerp(position1, position2, left_t),
- extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle2, left_t),
- extrapolated_pose.orientation);
-
- extrapolated_pose = predictor.Predict(eval_right_ns);
-
- const auto right_t =
- (eval_right_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
-
- TestPosition(lerp(position1, position2, right_t),
- extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle2, right_t),
- extrapolated_pose.orientation);
- }
-
- // Sending a duplicate sample here.
- predictor.Add(Pose{
- .position = position3, .orientation = orientation3, .time_ns = t2_ns});
-
- {
- // Extrapolate from t1 - t2 to eval_[left/right].
- extrapolated_pose = predictor.Predict(eval_left_ns);
-
- // The interpolation factors for left and right.
- const auto left_t =
- (eval_left_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
-
- TestPosition(lerp(position1, position3, left_t),
- extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle3, left_t),
- extrapolated_pose.orientation);
-
- extrapolated_pose = predictor.Predict(eval_right_ns);
-
- const auto right_t =
- (eval_right_ns - t1_ns) / static_cast<real>(t2_ns - t1_ns);
-
- // Test the result.
-
- TestPosition(lerp(position1, position3, right_t),
- extrapolated_pose.position);
-
- TestOrientation(qlerp(angle1, angle3, right_t),
- extrapolated_pose.orientation);
- }
-}
-
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/polynomial_predictor.cpp b/libs/vr/libposepredictor/polynomial_predictor.cpp
deleted file mode 100644
index 98fd28a..0000000
--- a/libs/vr/libposepredictor/polynomial_predictor.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <polynomial_predictor.h>
-
-namespace posepredictor {
-
-// Instantiate the common polynomial types.
-template class PolynomialPosePredictor<1, 2>;
-template class PolynomialPosePredictor<2, 3>;
-template class PolynomialPosePredictor<3, 4>;
-template class PolynomialPosePredictor<4, 5>;
-
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/polynomial_predictor_tests.cpp b/libs/vr/libposepredictor/polynomial_predictor_tests.cpp
deleted file mode 100644
index 88cb2b9..0000000
--- a/libs/vr/libposepredictor/polynomial_predictor_tests.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <polynomial_predictor.h>
-
-namespace posepredictor {
-
-namespace {
-
-// For comparing expected and actual.
-constexpr real kAbsErrorTolerance = 1e-5;
-
-// Test the linear extrapolation from two samples.
-TEST(PolynomialPosePredictor, Linear) {
- // Degree = 1, simple line, passing through two points.
- // Note the regularization is 0 so we expect the exact fit.
- PolynomialPosePredictor<1, 2> predictor(0);
-
- // Add two samples.
- predictor.Add(
- Pose{.position = {0, 0, 0}, .orientation = {0, 0, 0, 1}, .time_ns = 0});
-
- predictor.Add(
- Pose{.position = {1, 2, 3}, .orientation = {0, 0, 0, 1}, .time_ns = 10});
-
- Pose predicted_pose;
-
- predicted_pose = predictor.Predict(20);
-
- // Check the x,y,z components for the expected translation.
- EXPECT_NEAR(predicted_pose.position[0], 2, kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[1], 4, kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[2], 6, kAbsErrorTolerance);
-
- predicted_pose = predictor.Predict(30);
- EXPECT_NEAR(predicted_pose.position[0], 3, kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[1], 6, kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[2], 9, kAbsErrorTolerance);
-}
-
-// Test the degree two polynomial fit.
-TEST(PolynomialPosePredictor, Quadric) {
- // Degree = 2, need three samples to fit a polynomial.
- // Note the regularization is 0 so we expect the exact fit.
- PolynomialPosePredictor<2, 3> predictor(0);
-
- // Add three samples.
- predictor.Add(
- Pose{.position = {1, 2, 3}, .orientation = {0, 0, 0, 1}, .time_ns = 0});
-
- predictor.Add(
- Pose{.position = {0, 0, 0}, .orientation = {0, 0, 0, 1}, .time_ns = 10});
-
- predictor.Add(
- Pose{.position = {1, 2, 3}, .orientation = {0, 0, 0, 1}, .time_ns = 20});
-
- // The expected polynomials for x/y/z.
-
- // x: 0.01 * t^2 - 0.2 * t + 1
- const auto x = [](auto t) { return 0.01 * t * t - 0.2 * t + 1; };
-
- // y: 0.02 * t^2 - 0.4 * t + 2
- const auto y = [](auto t) { return 0.02 * t * t - 0.4 * t + 2; };
-
- // z: 0.03 * t^2 - 0.6 * t + 3
- const auto z = [](auto t) { return 0.03 * t * t - 0.6 * t + 3; };
-
- Pose predicted_pose;
- predicted_pose = predictor.Predict(40);
-
- // Check the x,y,z components for the expected translation.
- EXPECT_NEAR(predicted_pose.position[0], x(40), kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[1], y(40), kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[2], z(40), kAbsErrorTolerance);
-
- predicted_pose = predictor.Predict(50);
- EXPECT_NEAR(predicted_pose.position[0], x(50), kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[1], y(50), kAbsErrorTolerance);
- EXPECT_NEAR(predicted_pose.position[2], z(50), kAbsErrorTolerance);
-}
-
-// Test the degree two polynomial fit with degenerate input.
-//
-// The input samples all lie in a line which would normally make our system
-// degenerate. We will rely on the regularization term to recover the linear
-// solution in a quadric predictor.
-TEST(PolynomialPosePredictor, QuadricDegenate) {
- // Degree = 2, need three samples to fit a polynomial.
- // Note that we are using the default regularization term here.
- // We cannot use 0 regularizer since the input is degenerate.
- PolynomialPosePredictor<2, 3> predictor(1e-20);
-
- // Add three samples.
- predictor.Add(
- Pose{.position = {0, 0, 0}, .orientation = {0, 0, 0, 1}, .time_ns = 0});
-
- predictor.Add(
- Pose{.position = {1, 2, 3}, .orientation = {0, 0, 0, 1}, .time_ns = 10});
-
- predictor.Add(
- Pose{.position = {2, 4, 6}, .orientation = {0, 0, 0, 1}, .time_ns = 20});
-
- Pose predicted_pose;
-
- predicted_pose = predictor.Predict(30);
-
- // Check the x,y,z components for the expected translation.
- // We are using a higher error threshold since this is now approximate.
- EXPECT_NEAR(predicted_pose.position[0], 3, 0.001);
- EXPECT_NEAR(predicted_pose.position[1], 6, 0.001);
- EXPECT_NEAR(predicted_pose.position[2], 9, 0.001);
-
- predicted_pose = predictor.Predict(40);
- EXPECT_NEAR(predicted_pose.position[0], 4, 0.001);
- EXPECT_NEAR(predicted_pose.position[1], 8, 0.001);
- EXPECT_NEAR(predicted_pose.position[2], 12, 0.001);
-}
-
-} // namespace
-
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/predictor.cpp b/libs/vr/libposepredictor/predictor.cpp
deleted file mode 100644
index beba156..0000000
--- a/libs/vr/libposepredictor/predictor.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <linear_predictor.h>
-#include <polynomial_predictor.h>
-#include <predictor.h>
-
-namespace posepredictor {
-
-vec3 Predictor::AngularVelocity(const quat& a, const quat& b, real delta_time) {
- const auto delta_q = a.inverse() * b;
- // Check that delta_q.w() == 1, Eigen doesn't respect this convention. If
- // delta_q.w() == -1, we'll get the opposite velocity.
- return 2.0 * (delta_q.w() < 0 ? static_cast<vec3>(-delta_q.vec()) : delta_q.vec()) / delta_time;
-}
-
-Velocity Predictor::PredictVelocity(int64_t time_ns) const {
- const auto a = Predict(time_ns - kFiniteDifferenceNs);
- const auto b = Predict(time_ns + kFiniteDifferenceNs);
- const auto delta_time = NsToSeconds(2 * kFiniteDifferenceNs);
-
- return {(b.position - a.position) / delta_time,
- AngularVelocity(a.orientation, b.orientation, delta_time)};
-}
-
-// The factory method.
-std::unique_ptr<Predictor> Predictor::Create(PredictorType type) {
- switch (type) {
- case PredictorType::Linear:
- return std::make_unique<LinearPosePredictor>();
- case PredictorType::Quadric:
- return std::make_unique<QuadricPosePredictor>();
- case PredictorType::Cubic:
- return std::make_unique<CubicPosePredictor>();
- }
-}
-} // namespace posepredictor
diff --git a/libs/vr/libposepredictor/predictor_tests.cpp b/libs/vr/libposepredictor/predictor_tests.cpp
deleted file mode 100644
index e84a93a..0000000
--- a/libs/vr/libposepredictor/predictor_tests.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <predictor.h>
-
-namespace posepredictor {
-
-namespace {
-
-// For comparing expected and actual.
-constexpr real kAbsErrorTolerance = 1e-4;
-
-// Test the angular velocity computation from two orientations.
-TEST(PosePredictor, AngularVelocity) {
- // Some random rotation axis we will rotate around.
- const vec3 kRotationAxis = vec3(1, 2, 3).normalized();
-
- // Some random angle we will be rotating by.
- const real kRotationAngle = M_PI / 30;
-
- // Random start orientation we are currently at.
- const quat kStartOrientation = quat(5, 3, 4, 1).normalized();
-
- // The orientation we will end up at.
- const quat kEndOrientation =
- kStartOrientation *
- quat(Eigen::AngleAxis<real>(kRotationAngle, kRotationAxis));
-
- // The delta time for going from start orientation to end.
- const real kDeltaTime = 1.0;
-
- // Compute the angular velocity from start orientation to end.
- const auto angularVelocity = Predictor::AngularVelocity(
- kStartOrientation, kEndOrientation, kDeltaTime);
-
- // Extract the axis and the angular speed.
- const auto angularSpeed = angularVelocity.norm();
- const auto rotationAxis = angularVelocity.normalized();
-
- // The speed must match.
- EXPECT_NEAR(angularSpeed, kRotationAngle / kDeltaTime, kAbsErrorTolerance);
-
- // The rotation axis must match.
- EXPECT_NEAR(rotationAxis[0], kRotationAxis[0], kAbsErrorTolerance);
- EXPECT_NEAR(rotationAxis[1], kRotationAxis[1], kAbsErrorTolerance);
- EXPECT_NEAR(rotationAxis[2], kRotationAxis[2], kAbsErrorTolerance);
-}
-
-} // namespace
-
-} // namespace posepredictor
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index 40979c9..04ab78f 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -69,8 +69,7 @@
mCBContext(),
mEventHandler(nullptr),
mVSyncCounts(),
- mRemainingHwcVirtualDisplays(0),
- mDumpMayLockUp(false)
+ mRemainingHwcVirtualDisplays(0)
{
for (size_t i=0 ; i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {
mLastHwVSync[i] = 0;
@@ -494,8 +493,6 @@
return NO_ERROR;
}
- mDumpMayLockUp = true;
-
uint32_t numTypes = 0;
uint32_t numRequests = 0;
auto error = hwcDisplay->validate(&numTypes, &numRequests);
@@ -636,9 +633,6 @@
auto& displayData = mDisplayData[displayId];
auto& hwcDisplay = displayData.hwcDisplay;
auto error = hwcDisplay->present(&displayData.lastPresentFence);
-
- mDumpMayLockUp = false;
-
if (error != HWC2::Error::None) {
ALOGE("presentAndGetReleaseFences: failed for display %d: %s (%d)",
displayId, to_string(error).c_str(), static_cast<int32_t>(error));
@@ -884,11 +878,6 @@
}
void HWComposer::dump(String8& result) const {
- if (mDumpMayLockUp) {
- result.append("HWComposer dump skipped because present in progress");
- return;
- }
-
// TODO: In order to provide a dump equivalent to HWC1, we need to shadow
// all the state going into the layers. This is probably better done in
// Layer itself, but it's going to take a bit of work to get there.
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 78d0307..631af14 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -224,9 +224,6 @@
// thread-safe
mutable Mutex mVsyncLock;
-
- // XXX temporary workaround for b/35806047
- mutable std::atomic<bool> mDumpMayLockUp;
};
// ---------------------------------------------------------------------------