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

Commit a1f17751 authored by Tom Cherry's avatar Tom Cherry Committed by Gerrit Code Review
Browse files

Merge changes I957c519b,Iaf4e389e,I92f8056b 

* changes:
  logd: remove faulty optimization
  logd: don't store the map key in its value
  logd: use libbase logging
parents e10fb5f5 b0263af5

logd/ChattyLogBuffer.cpp

+2 −2
Original line number Diff line number Diff line
@@ -217,12 +217,12 @@ LogBufferElementCollection::iterator ChattyLogBuffer::Erase(LogBufferElementColl 
    log_id_for_each(i) {

        for (auto b : mLastWorst[i]) {

            if (bad == b.second) {

                android::prdebug("stale mLastWorst[%d] key=%d mykey=%d\n", i, b.first, key);

                LOG(ERROR) << StringPrintf("stale mLastWorst[%d] key=%d mykey=%d", i, b.first, key);

            }

        }

        for (auto b : mLastWorstPidOfSystem[i]) {

            if (bad == b.second) {

                android::prdebug("stale mLastWorstPidOfSystem[%d] pid=%d\n", i, b.first);

                LOG(ERROR) << StringPrintf("stale mLastWorstPidOfSystem[%d] pid=%d", i, b.first);

            }

        }

    }

logd/CommandListener.cpp

+2 −1
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 


#include <string>



#include <android-base/logging.h>

#include <android-base/stringprintf.h>

#include <cutils/sockets.h>

#include <log/log_properties.h>
@@ -298,7 +299,7 @@ int CommandListener::ReinitCmd::runCommand(SocketClient* cli, int /*argc*/, 
                                           char** /*argv*/) {

    setname();



    android::prdebug("logd reinit");

    LOG(INFO) << "logd reinit";

    buf()->Init();

    prune()->init(nullptr);

logd/LogBufferTest.cpp

+0 −8
Original line number Diff line number Diff line
@@ -43,14 +43,6 @@ bool __android_logger_valid_buffer_size(unsigned long) { 
}

#endif



void android::prdebug(const char* fmt, ...) {

    va_list ap;

    va_start(ap, fmt);

    vfprintf(stderr, fmt, ap);

    fprintf(stderr, "\n");

    va_end(ap);

}



char* android::uidToName(uid_t) {

    return nullptr;

}

logd/LogReader.cpp

+3 −2
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 


#include <chrono>



#include <android-base/logging.h>

#include <android-base/stringprintf.h>

#include <cutils/sockets.h>

#include <private/android_filesystem_config.h>
@@ -201,9 +202,9 @@ bool LogReader::onDataAvailable(SocketClient* cli) { 
        }

    }



    android::prdebug(

    LOG(INFO) << android::base::StringPrintf(

            "logdr: UID=%d GID=%d PID=%d %c tail=%lu logMask=%x pid=%d "

            "start=%" PRIu64 "ns deadline=%" PRIi64 "ns\n",

            "start=%" PRIu64 "ns deadline=%" PRIi64 "ns",

            cli->getUid(), cli->getGid(), cli->getPid(), nonBlock ? 'n' : 'b', tail, logMask,

            (int)pid, start.nsec(), static_cast<int64_t>(deadline.time_since_epoch().count()));

logd/LogStatistics.cpp

+54 −26
Original line number Diff line number Diff line
@@ -36,6 +36,30 @@ static const uint64_t monthSec = 31 * 24 * hourSec; 


std::atomic<size_t> LogStatistics::SizesTotal;



static std::string TagNameKey(const LogStatisticsElement& element) {

    if (IsBinary(element.log_id)) {

        uint32_t tag = element.tag;

        if (tag) {

            const char* cp = android::tagToName(tag);

            if (cp) {

                return std::string(cp);

            }

        }

        return android::base::StringPrintf("[%" PRIu32 "]", tag);

    }

    const char* msg = element.msg;

    if (!msg) {

        return "chatty";

    }

    ++msg;

    uint16_t len = element.msg_len;

    len = (len <= 1) ? 0 : strnlen(msg, len - 1);

    if (!len) {

        return "<NULL>";

    }

    return std::string(msg, len);

}



LogStatistics::LogStatistics(bool enable_statistics) : enable(enable_statistics) {

    log_time now(CLOCK_REALTIME);

    log_id_for_each(id) {
@@ -308,8 +332,9 @@ template <typename TKey, typename TEntry> 
void LogStatistics::WorstTwoWithThreshold(const LogHashtable<TKey, TEntry>& table, size_t threshold,

                                          int* worst, size_t* worst_sizes,

                                          size_t* second_worst_sizes) const {

    std::array<const TKey*, 2> max_keys;

    std::array<const TEntry*, 2> max_entries;

    table.MaxEntries(AID_ROOT, 0, &max_entries);

    table.MaxEntries(AID_ROOT, 0, max_keys, max_entries);

    if (max_entries[0] == nullptr || max_entries[1] == nullptr) {

        return;

    }
@@ -317,7 +342,7 @@ void LogStatistics::WorstTwoWithThreshold(const LogHashtable<TKey, TEntry>& tabl 
    // b/24782000: Allow time horizon to extend roughly tenfold, assume average entry length is

    // 100 characters.

    if (*worst_sizes > threshold && *worst_sizes > (10 * max_entries[0]->dropped_count())) {

        *worst = max_entries[0]->key();

        *worst = *max_keys[0];

        *second_worst_sizes = max_entries[1]->getSizes();

        if (*second_worst_sizes < threshold) {

            *second_worst_sizes = threshold;
@@ -340,13 +365,14 @@ void LogStatistics::WorstTwoTags(size_t threshold, int* worst, size_t* worst_siz 
void LogStatistics::WorstTwoSystemPids(log_id id, size_t worst_uid_sizes, int* worst,

                                       size_t* second_worst_sizes) const {

    auto lock = std::lock_guard{lock_};

    std::array<const pid_t*, 2> max_keys;

    std::array<const PidEntry*, 2> max_entries;

    pidSystemTable[id].MaxEntries(AID_SYSTEM, 0, &max_entries);

    pidSystemTable[id].MaxEntries(AID_SYSTEM, 0, max_keys, max_entries);

    if (max_entries[0] == nullptr || max_entries[1] == nullptr) {

        return;

    }



    *worst = max_entries[0]->key();

    *worst = *max_keys[0];

    *second_worst_sizes = worst_uid_sizes - max_entries[0]->getSizes() + max_entries[1]->getSizes();

}
@@ -412,11 +438,12 @@ void LogStatistics::FormatTmp(const char* nameTmp, uid_t uid, std::string& name, 
    }

}



std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUIRES(stat.lock_) {

    std::string name = android::base::StringPrintf("%u", uid_);

std::string UidEntry::format(const LogStatistics& stat, log_id_t id, uid_t uid) const

        REQUIRES(stat.lock_) {

    std::string name = android::base::StringPrintf("%u", uid);

    std::string size = android::base::StringPrintf("%zu", getSizes());



    stat.FormatTmp(nullptr, uid_, name, size, 6);

    stat.FormatTmp(nullptr, uid, name, size, 6);



    std::string pruned = "";

    if (worstUidEnabledForLogid(id)) {
@@ -474,19 +501,20 @@ std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUI 


    std::string output = formatLine(name, size, pruned);



    if (uid_ != AID_SYSTEM) {

    if (uid != AID_SYSTEM) {

        return output;

    }



    static const size_t maximum_sorted_entries = 32;

    std::array<const PidEntry*, maximum_sorted_entries> sorted;

    stat.pidSystemTable[id].MaxEntries(uid_, 0, &sorted);

    std::array<const pid_t*, maximum_sorted_entries> sorted_pids;

    std::array<const PidEntry*, maximum_sorted_entries> sorted_entries;

    stat.pidSystemTable[id].MaxEntries(uid, 0, sorted_pids, sorted_entries);



    std::string byPid;

    size_t index;

    bool hasDropped = false;

    for (index = 0; index < maximum_sorted_entries; ++index) {

        const PidEntry* entry = sorted[index];

        const PidEntry* entry = sorted_entries[index];

        if (!entry) {

            break;

        }
@@ -496,7 +524,7 @@ std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUI 
        if (entry->dropped_count()) {

            hasDropped = true;

        }

        byPid += entry->format(stat, id);

        byPid += entry->format(stat, id, *sorted_pids[index]);

    }

    if (index > 1) {  // print this only if interesting

        std::string ditto("\" ");
@@ -515,9 +543,9 @@ std::string PidEntry::formatHeader(const std::string& name, 
                      std::string("BYTES"), std::string("NUM"));

}



std::string PidEntry::format(const LogStatistics& stat, log_id_t /* id */) const

std::string PidEntry::format(const LogStatistics& stat, log_id_t, pid_t pid) const

        REQUIRES(stat.lock_) {

    std::string name = android::base::StringPrintf("%5u/%u", pid_, uid_);

    std::string name = android::base::StringPrintf("%5u/%u", pid, uid_);

    std::string size = android::base::StringPrintf("%zu", getSizes());



    stat.FormatTmp(name_, uid_, name, size, 12);
@@ -538,9 +566,9 @@ std::string TidEntry::formatHeader(const std::string& name, 
                      std::string("NUM"));

}



std::string TidEntry::format(const LogStatistics& stat, log_id_t /* id */) const

std::string TidEntry::format(const LogStatistics& stat, log_id_t, pid_t tid) const

        REQUIRES(stat.lock_) {

    std::string name = android::base::StringPrintf("%5u/%u", tid(), uid_);

    std::string name = android::base::StringPrintf("%5u/%u", tid, uid_);

    std::string size = android::base::StringPrintf("%zu", getSizes());



    stat.FormatTmp(name_, uid_, name, size, 12);
@@ -562,8 +590,7 @@ std::string TagEntry::formatHeader(const std::string& name, log_id_t id) const { 
                      std::string("BYTES"), std::string(isprune ? "NUM" : ""));

}



std::string TagEntry::format(const LogStatistics& /* stat */,

                             log_id_t /* id */) const {

std::string TagEntry::format(const LogStatistics&, log_id_t, uint32_t) const {

    std::string name;

    if (uid_ == (uid_t)-1) {

        name = android::base::StringPrintf("%7u", key());
@@ -594,8 +621,8 @@ std::string TagNameEntry::formatHeader(const std::string& name, 
                      std::string("BYTES"), std::string(""));

}



std::string TagNameEntry::format(const LogStatistics& /* stat */,

                                 log_id_t /* id */) const {

std::string TagNameEntry::format(const LogStatistics&, log_id_t,

                                 const std::string& key_name) const {

    std::string name;

    std::string pidstr;

    if (pid_ != (pid_t)-1) {
@@ -616,7 +643,7 @@ std::string TagNameEntry::format(const LogStatistics& /* stat */, 


    std::string size = android::base::StringPrintf("%zu", getSizes());



    const char* nameTmp = this->name();

    const char* nameTmp = key_name.data();

    if (nameTmp) {

        size_t lenSpace = std::max(16 - name.length(), (size_t)1);

        size_t len = EntryBase::TOTAL_LEN - EntryBase::PRUNED_LEN - size.length() - name.length() -
@@ -684,15 +711,16 @@ std::string LogStatistics::FormatTable(const LogHashtable<TKey, TEntry>& table, 
        REQUIRES(lock_) {

    static const size_t maximum_sorted_entries = 32;

    std::string output;

    std::array<const TEntry*, maximum_sorted_entries> sorted;

    table.MaxEntries(uid, pid, &sorted);

    std::array<const TKey*, maximum_sorted_entries> sorted_keys;

    std::array<const TEntry*, maximum_sorted_entries> sorted_entries;

    table.MaxEntries(uid, pid, sorted_keys, sorted_entries);

    bool header_printed = false;

    for (size_t index = 0; index < maximum_sorted_entries; ++index) {

        const TEntry* entry = sorted[index];

        const TEntry* entry = sorted_entries[index];

        if (!entry) {

            break;

        }

        if (entry->getSizes() <= (sorted[0]->getSizes() / 100)) {

        if (entry->getSizes() <= (sorted_entries[0]->getSizes() / 100)) {

            break;

        }

        if (!header_printed) {
@@ -700,7 +728,7 @@ std::string LogStatistics::FormatTable(const LogHashtable<TKey, TEntry>& table, 
            output += entry->formatHeader(name, id);

            header_printed = true;

        }

        output += entry->format(*this, id);

        output += entry->format(*this, id, *sorted_keys[index]);

    }

    return output;

}