Home | History | Annotate | Download | only in lshal 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
     18 #define FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
     19 
     20 #include <stdint.h>
     21 
     22 #include <string>
     23 #include <vector>
     24 #include <iostream>
     25 
     26 #include <procpartition/procpartition.h>
     27 #include <vintf/Arch.h>
     28 #include <vintf/Transport.h>
     29 
     30 #include "TextTable.h"
     31 
     32 namespace android {
     33 namespace lshal {
     34 
     35 using android::procpartition::Partition;
     36 using Pids = std::vector<int32_t>;
     37 
     38 enum class TableColumnType : unsigned int {
     39     INTERFACE_NAME,
     40     TRANSPORT,
     41     SERVER_PID,
     42     SERVER_CMD,
     43     SERVER_ADDR,
     44     CLIENT_PIDS,
     45     CLIENT_CMDS,
     46     ARCH,
     47     THREADS,
     48     RELEASED,
     49     HASH,
     50     VINTF,
     51     SERVICE_STATUS,
     52 };
     53 
     54 enum : unsigned int {
     55     VINTF_INFO_EMPTY = 0,
     56     DEVICE_MANIFEST = 1 << 0,
     57     DEVICE_MATRIX = 1 << 1,
     58     FRAMEWORK_MANIFEST = 1 << 2,
     59     FRAMEWORK_MATRIX = 1 << 3,
     60 };
     61 using VintfInfo = unsigned int;
     62 
     63 enum {
     64     NO_PID = -1,
     65     NO_PTR = 0
     66 };
     67 
     68 enum class ServiceStatus {
     69     UNKNOWN, // For passthrough
     70     ALIVE,
     71     NON_RESPONSIVE, // registered but not respond to calls
     72     DECLARED, // in VINTF manifest
     73 };
     74 std::string to_string(ServiceStatus s);
     75 
     76 struct TableEntry {
     77     std::string interfaceName{};
     78     vintf::Transport transport{vintf::Transport::EMPTY};
     79     int32_t serverPid{NO_PID};
     80     uint32_t threadUsage{0};
     81     uint32_t threadCount{0};
     82     std::string serverCmdline{};
     83     uint64_t serverObjectAddress{NO_PTR};
     84     Pids clientPids{};
     85     std::vector<std::string> clientCmdlines{};
     86     vintf::Arch arch{vintf::Arch::ARCH_EMPTY};
     87     // empty: unknown, all zeros: unreleased, otherwise: released
     88     std::string hash{};
     89     Partition partition{Partition::UNKNOWN};
     90     VintfInfo vintfInfo{VINTF_INFO_EMPTY};
     91     // true iff hwbinder and service started
     92     ServiceStatus serviceStatus{ServiceStatus::UNKNOWN};
     93 
     94     static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) {
     95         return a.interfaceName < b.interfaceName;
     96     };
     97     static bool sortByServerPid(const TableEntry &a, const TableEntry &b) {
     98         return a.serverPid < b.serverPid;
     99     };
    100 
    101     std::string getThreadUsage() const {
    102         if (threadCount == 0) {
    103             return "N/A";
    104         }
    105 
    106         return std::to_string(threadUsage) + "/" + std::to_string(threadCount);
    107     }
    108 
    109     std::string isReleased() const;
    110 
    111     std::string getVintfInfo() const;
    112 
    113     std::string getField(TableColumnType type) const;
    114 
    115     bool operator==(const TableEntry& other) const;
    116     std::string to_string() const;
    117 };
    118 
    119 using SelectedColumns = std::vector<TableColumnType>;
    120 
    121 class Table {
    122 public:
    123     using Entries = std::vector<TableEntry>;
    124 
    125     Entries::iterator begin() { return mEntries.begin(); }
    126     Entries::const_iterator begin() const { return mEntries.begin(); }
    127     Entries::iterator end() { return mEntries.end(); }
    128     Entries::const_iterator end() const { return mEntries.end(); }
    129     size_t size() const { return mEntries.size(); }
    130 
    131     void add(TableEntry&& entry) { mEntries.push_back(std::move(entry)); }
    132 
    133     void setSelectedColumns(const SelectedColumns& s) { mSelectedColumns = s; }
    134     const SelectedColumns& getSelectedColumns() const { return mSelectedColumns; }
    135 
    136     void setDescription(std::string&& d) { mDescription = std::move(d); }
    137 
    138     // Write table content.
    139     TextTable createTextTable(bool neat = true,
    140         const std::function<std::string(const std::string&)>& emitDebugInfo = nullptr) const;
    141 
    142 private:
    143     std::string mDescription;
    144     Entries mEntries;
    145     SelectedColumns mSelectedColumns;
    146 };
    147 
    148 using TableEntryCompare = std::function<bool(const TableEntry &, const TableEntry &)>;
    149 
    150 class MergedTable {
    151 public:
    152     explicit MergedTable(std::vector<const Table*>&& tables) : mTables(std::move(tables)) {}
    153     TextTable createTextTable();
    154 private:
    155     std::vector<const Table*> mTables;
    156 };
    157 
    158 }  // namespace lshal
    159 }  // namespace android
    160 
    161 #endif  // FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
    162