Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 136c4bc7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes from topic "lshal_released" 

* changes:
  lshal: add Released column.
  lshal: clean up ListCommand::fetchBinderized
  lshal: ListCommand::getPidInfo should be cached.
  lshal: fix tests on implementation
  lshal: omit description text in tests.
parents 757fd44b fee209dd

cmds/lshal/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ cc_library_shared { 
        "libutils",

        "libhidlbase",

        "libhidltransport",

        "libhidl-gen-hash",

        "libhidl-gen-utils",

        "libvintf",

    ],

cmds/lshal/ListCommand.cpp

+129 −77
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 


#include <android-base/parseint.h>

#include <android/hidl/manager/1.0/IServiceManager.h>

#include <hidl-hash/Hash.h>

#include <hidl-util/FQName.h>

#include <private/android_filesystem_config.h>

#include <sys/stat.h>
@@ -39,6 +40,9 @@ 
#include "utils.h"



using ::android::hardware::hidl_string;

using ::android::hardware::hidl_vec;

using ::android::hidl::base::V1_0::DebugInfo;

using ::android::hidl::base::V1_0::IBase;

using ::android::hidl::manager::V1_0::IServiceManager;



namespace android {
@@ -85,7 +89,7 @@ void ListCommand::removeDeadProcesses(Pids *pids) { 
    }), pids->end());

}



bool scanBinderContext(pid_t pid,

static bool scanBinderContext(pid_t pid,

        const std::string &contextName,

        std::function<void(const std::string&)> eachLine) {

    std::ifstream ifs("/d/binder/proc/" + std::to_string(pid));
@@ -171,6 +175,16 @@ bool ListCommand::getPidInfo( 
    });

}



const PidInfo* ListCommand::getPidInfoCached(pid_t serverPid) {

    auto pair = mCachedPidInfos.insert({serverPid, PidInfo{}});

    if (pair.second /* did insertion take place? */) {

        if (!getPidInfo(serverPid, &pair.first->second)) {

            return nullptr;

        }

    }

    return &pair.first->second;

}



// Must process hwbinder services first, then passthrough services.

void ListCommand::forEachTable(const std::function<void(Table &)> &f) {

    f(mServicesTable);
@@ -445,10 +459,7 @@ Status ListCommand::fetchAllLibraries(const sp<IServiceManager> &manager) { 
            entries.emplace(interfaceName, TableEntry{

                .interfaceName = interfaceName,

                .transport = "passthrough",

                .serverPid = NO_PID,

                .serverObjectAddress = NO_PTR,

                .clientPids = info.clientPids,

                .arch = ARCH_UNKNOWN

            }).first->second.arch |= fromBaseArchitecture(info.arch);

        }

        for (auto &&pair : entries) {
@@ -479,7 +490,6 @@ Status ListCommand::fetchPassthrough(const sp<IServiceManager> &manager) { 
                        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)

            });
@@ -494,10 +504,6 @@ Status ListCommand::fetchPassthrough(const sp<IServiceManager> &manager) { 
}



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;
@@ -512,80 +518,117 @@ Status ListCommand::fetchBinderized(const sp<IServiceManager> &manager) { 
    }



    Status status = OK;

    // server pid, .ptr value of binder object, child pids

    std::map<std::string, DebugInfo> allDebugInfos;

    std::map<pid_t, PidInfo> allPids;

    std::map<std::string, TableEntry> allTableEntries;

    for (const auto &fqInstanceName : fqInstanceNames) {

        const auto pair = splitFirst(fqInstanceName, '/');

        // create entry and default assign all fields.

        TableEntry& entry = allTableEntries[fqInstanceName];

        entry.interfaceName = fqInstanceName;

        entry.transport = mode;



        status |= fetchBinderizedEntry(manager, &entry);

    }



    for (auto& pair : allTableEntries) {

        putEntry(HWSERVICEMANAGER_LIST, std::move(pair.second));

    }

    return status;

}



Status ListCommand::fetchBinderizedEntry(const sp<IServiceManager> &manager,

                                         TableEntry *entry) {

    Status status = OK;

    const auto handleError = [&](Status additionalError, const std::string& msg) {

        err() << "Warning: Skipping \"" << entry->interfaceName << "\": " << msg << std::endl;

        status |= DUMP_BINDERIZED_ERROR | additionalError;

    };



    const auto pair = splitFirst(entry->interfaceName, '/');

    const auto &serviceName = pair.first;

    const auto &instanceName = pair.second;

    auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName);

    if (!getRet.isOk()) {

            err() << "Warning: Skipping \"" << fqInstanceName << "\": "

                 << "cannot be fetched from service manager:"

                 << getRet.description() << std::endl;

            status |= DUMP_BINDERIZED_ERROR;

            continue;

        handleError(TRANSACTION_ERROR,

                    "cannot be fetched from service manager:" + getRet.description());

        return status;

    }

    sp<IBase> service = getRet;

    if (service == nullptr) {

            err() << "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)] = PidInfo();

        handleError(NO_INTERFACE, "cannot be fetched from service manager (null)");

        return status;

    }



    // getDebugInfo

    do {

        DebugInfo debugInfo;

        auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &received) {

            debugInfo = received;

        });

        if (!debugRet.isOk()) {

            err() << "Warning: Skipping \"" << fqInstanceName << "\": "

                 << "debugging information cannot be retrieved:"

                 << debugRet.description() << std::endl;

            status |= DUMP_BINDERIZED_ERROR;

            handleError(TRANSACTION_ERROR,

                        "debugging information cannot be retrieved: " + debugRet.description());

            break; // skip getPidInfo

        }



        entry->serverPid = debugInfo.pid;

        entry->serverObjectAddress = debugInfo.ptr;

        entry->arch = fromBaseArchitecture(debugInfo.arch);



        if (debugInfo.pid != NO_PID) {

            const PidInfo* pidInfo = getPidInfoCached(debugInfo.pid);

            if (pidInfo == nullptr) {

                handleError(IO_ERROR,

                            "no information for PID " + std::to_string(debugInfo.pid) +

                            ", are you root?");

                break;

            }

            if (debugInfo.ptr != NO_PTR) {

                auto it = pidInfo->refPids.find(debugInfo.ptr);

                if (it != pidInfo->refPids.end()) {

                    entry->clientPids = it->second;

                }

            }

            entry->threadUsage = pidInfo->threadUsage;

            entry->threadCount = pidInfo->threadCount;

        }

    } while (0);



    for (auto &pair : allPids) {

        pid_t serverPid = pair.first;

        if (!getPidInfo(serverPid, &allPids[serverPid])) {

            err() << "Warning: no information for PID " << serverPid

                      << ", are you root?" << std::endl;

            status |= DUMP_BINDERIZED_ERROR;

    // hash

    do {

        ssize_t hashIndex = -1;

        auto ifaceChainRet = timeoutIPC(service, &IBase::interfaceChain, [&] (const auto& c) {

            for (size_t i = 0; i < c.size(); ++i) {

                if (serviceName == c[i]) {

                    hashIndex = static_cast<ssize_t>(i);

                    break;

                }

            }

    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 = {},

                .threadUsage = 0,

                .threadCount = 0,

                .arch = ARCH_UNKNOWN

        });

            continue;

        if (!ifaceChainRet.isOk()) {

            handleError(TRANSACTION_ERROR,

                        "interfaceChain fails: " + ifaceChainRet.description());

            break; // skip getHashChain

        }

        if (hashIndex < 0) {

            handleError(BAD_IMPL, "Interface name does not exist in interfaceChain.");

            break; // skip getHashChain

        }

        auto hashRet = timeoutIPC(service, &IBase::getHashChain, [&] (const auto& hashChain) {

            if (static_cast<size_t>(hashIndex) >= hashChain.size()) {

                handleError(BAD_IMPL,

                            "interfaceChain indicates position " + std::to_string(hashIndex) +

                            " but getHashChain returns " + std::to_string(hashChain.size()) +

                            " hashes");

                return;

            }

        const DebugInfo &info = it->second;

        bool writePidInfo = info.pid != NO_PID && info.ptr != NO_PTR;



        putEntry(HWSERVICEMANAGER_LIST, {

            .interfaceName = fqInstanceName,

            .transport = mode,

            .serverPid = info.pid,

            .serverObjectAddress = info.ptr,

            .clientPids = writePidInfo ? allPids[info.pid].refPids[info.ptr] : Pids{},

            .threadUsage = writePidInfo ? allPids[info.pid].threadUsage : 0,

            .threadCount = writePidInfo ? allPids[info.pid].threadCount : 0,

            .arch = fromBaseArchitecture(info.arch),



            auto&& hashArray = hashChain[hashIndex];

            std::vector<uint8_t> hashVec{hashArray.data(), hashArray.data() + hashArray.size()};

            entry->hash = Hash::hexString(hashVec);

        });

        if (!hashRet.isOk()) {

            handleError(TRANSACTION_ERROR, "getHashChain failed: " + hashRet.description());

        }

    } while (0);

    return status;

}
@@ -623,6 +666,10 @@ void ListCommand::registerAllOptions() { 
        thiz->mSelectedColumns.push_back(TableColumnType::INTERFACE_NAME);

        return OK;

    }, "print the instance name column"});

    mOptions.push_back({'l', "released", no_argument, v++, [](ListCommand* thiz, const char*) {

        thiz->mSelectedColumns.push_back(TableColumnType::RELEASED);

        return OK;

    }, "print the 'is released?' column\n(Y=released, empty=unreleased or unknown)"});

    mOptions.push_back({'t', "transport", no_argument, v++, [](ListCommand* thiz, const char*) {

        thiz->mSelectedColumns.push_back(TableColumnType::TRANSPORT);

        return OK;
@@ -631,6 +678,10 @@ void ListCommand::registerAllOptions() { 
        thiz->mSelectedColumns.push_back(TableColumnType::ARCH);

        return OK;

    }, "print the bitness column"});

    mOptions.push_back({'s', "hash", no_argument, v++, [](ListCommand* thiz, const char*) {

        thiz->mSelectedColumns.push_back(TableColumnType::HASH);

        return OK;

    }, "print hash of the interface"});

    mOptions.push_back({'p', "pid", no_argument, v++, [](ListCommand* thiz, const char*) {

        thiz->mSelectedColumns.push_back(TableColumnType::SERVER_PID);

        return OK;
@@ -773,7 +824,8 @@ Status ListCommand::parseArgs(const Arg &arg) { 
    }



    if (mSelectedColumns.empty()) {

        mSelectedColumns = {TableColumnType::INTERFACE_NAME, TableColumnType::THREADS,

        mSelectedColumns = {TableColumnType::RELEASED,

                            TableColumnType::INTERFACE_NAME, TableColumnType::THREADS,

                            TableColumnType::SERVER_PID, TableColumnType::CLIENT_PIDS};

    }
@@ -841,7 +893,7 @@ void ListCommand::usage() const { 
    err() << "list:" << std::endl

          << "    lshal" << std::endl

          << "    lshal list" << std::endl

          << "        List all hals with default ordering and columns (`lshal list -iepc`)" << std::endl

          << "        List all hals with default ordering and columns (`lshal list -riepc`)" << std::endl

          << "    lshal list [-h|--help]" << std::endl

          << "        -h, --help: Print help message for list (`lshal help list`)" << std::endl

          << "    lshal [list] [OPTIONS...]" << std::endl;

cmds/lshal/ListCommand.h

+11 −1
Original line number Diff line number Diff line
@@ -78,14 +78,21 @@ public: 
protected:

    Status parseArgs(const Arg &arg);

    Status fetch();

    void postprocess();

    virtual void postprocess();

    Status 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);



    Status fetchBinderizedEntry(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager,

                                TableEntry *entry);



    // Get relevant information for a PID by parsing files under /d/binder.

    // It is a virtual member function so that it can be mocked.

    virtual bool getPidInfo(pid_t serverPid, PidInfo *info) const;

    // Retrieve from mCachedPidInfos and call getPidInfo if necessary.

    const PidInfo* getPidInfoCached(pid_t serverPid);



    void dumpTable(const NullableOStream<std::ostream>& out) const;

    void dumpVintf(const NullableOStream<std::ostream>& out) const;
@@ -129,6 +136,9 @@ protected: 
    // If an entry exist and not empty, it contains the cached content of /proc/{pid}/cmdline.

    std::map<pid_t, std::string> mCmdlines;



    // Cache for getPidInfo.

    std::map<pid_t, PidInfo> mCachedPidInfos;



    RegisteredOptions mOptions;

    // All selected columns

    std::vector<TableColumnType> mSelectedColumns;

cmds/lshal/TableEntry.cpp

+19 −2
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 
#define LOG_TAG "lshal"

#include <android-base/logging.h>



#include <hidl-hash/Hash.h>



#include "TableEntry.h"



#include "TextTable.h"
@@ -53,8 +55,10 @@ static std::string getTitle(TableColumnType type) { 
        case TableColumnType::CLIENT_CMDS:      return "Clients CMD";

        case TableColumnType::ARCH:             return "Arch";

        case TableColumnType::THREADS:          return "Thread Use";

        case TableColumnType::RELEASED:         return "R";

        case TableColumnType::HASH:             return "Hash";

        default:

            LOG(FATAL) << "Should not reach here.";

            LOG(FATAL) << __func__ << "Should not reach here. " << static_cast<int>(type);

            return "";

    }

}
@@ -79,12 +83,25 @@ std::string TableEntry::getField(TableColumnType type) const { 
            return getArchString(arch);

        case TableColumnType::THREADS:

            return getThreadUsage();

        case TableColumnType::RELEASED:

            return isReleased();

        case TableColumnType::HASH:

            return hash;

        default:

            LOG(FATAL) << "Should not reach here.";

            LOG(FATAL) << __func__ << "Should not reach here. " << static_cast<int>(type);

            return "";

    }

}



std::string TableEntry::isReleased() const {

    static const std::string unreleased = Hash::hexString(Hash::kEmptyHash);



    if (hash.empty() || hash == unreleased) {

        return " "; // unknown or unreleased

    }

    return "Y"; // released

}



TextTable Table::createTextTable(bool neat,

    const std::function<std::string(const std::string&)>& emitDebugInfo) const {

cmds/lshal/TableEntry.h

+21 −15
Original line number Diff line number Diff line
@@ -55,19 +55,28 @@ enum class TableColumnType : unsigned int { 
    CLIENT_CMDS,

    ARCH,

    THREADS,

    RELEASED,

    HASH,

};



enum {

    NO_PID = -1,

    NO_PTR = 0

};



struct TableEntry {

    std::string interfaceName;

    std::string transport;

    int32_t serverPid;

    uint32_t threadUsage;

    uint32_t threadCount;

    std::string serverCmdline;

    uint64_t serverObjectAddress;

    Pids clientPids;

    std::vector<std::string> clientCmdlines;

    Architecture arch;

    std::string interfaceName{};

    std::string transport{};

    int32_t serverPid{NO_PID};

    uint32_t threadUsage{0};

    uint32_t threadCount{0};

    std::string serverCmdline{};

    uint64_t serverObjectAddress{NO_PTR};

    Pids clientPids{};

    std::vector<std::string> clientCmdlines{};

    Architecture arch{ARCH_UNKNOWN};

    // empty: unknown, all zeros: unreleased, otherwise: released

    std::string hash{};



    static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) {

        return a.interfaceName < b.interfaceName;
@@ -84,6 +93,8 @@ struct TableEntry { 
        return std::to_string(threadUsage) + "/" + std::to_string(threadCount);

    }



    std::string isReleased() const;



    std::string getField(TableColumnType type) const;



    bool operator==(const TableEntry& other) const;
@@ -129,11 +140,6 @@ private: 
    std::vector<const Table*> mTables;

};



enum {

    NO_PID = -1,

    NO_PTR = 0

};



}  // namespace lshal

}  // namespace android