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

Commit b78387a5 authored by Tom Cherry's avatar Tom Cherry Committed by Automerger Merge Worker
Browse files

Merge "logd: Drop the LogStatistics dependency on LogBufferElement" am:... 

Merge "logd: Drop the LogStatistics dependency on LogBufferElement" am: 671f39fd am: 430dbf32 am: d17e29cc am: 03b381cc am: 4f1ce69e

Original change: https://android-review.googlesource.com/c/platform/system/core/+/1322276

Change-Id: Ic8a3deef5d93b688ca6a8313369a82dd2087f85f
parents 5880b919 4f1ce69e

logd/ChattyLogBuffer.cpp

+5 −4
Original line number Diff line number Diff line
@@ -74,7 +74,8 @@ static enum match_type Identical(const LogBufferElement& elem, const LogBufferEl 
    }



    // audit message (except sequence number) identical?

    if (last.IsBinary() && lenl > static_cast<ssize_t>(sizeof(android_log_event_string_t)) &&

    if (IsBinary(last.log_id()) &&

        lenl > static_cast<ssize_t>(sizeof(android_log_event_string_t)) &&

        lenr > static_cast<ssize_t>(sizeof(android_log_event_string_t))) {

        if (fastcmp<memcmp>(msgl, msgr, sizeof(android_log_event_string_t) - sizeof(int32_t))) {

            return DIFFERENT;
@@ -205,9 +206,9 @@ LogBufferElementCollection::iterator ChattyLogBuffer::Erase(LogBufferElementColl 
#endif



    if (coalesce) {

        stats()->Erase(element);

        stats()->Erase(element.ToLogStatisticsElement());

    } else {

        stats()->Subtract(element);

        stats()->Subtract(element.ToLogStatisticsElement());

    }



    it = SimpleLogBuffer::Erase(it);
@@ -533,7 +534,7 @@ bool ChattyLogBuffer::Prune(log_id_t id, unsigned long pruneRows, uid_t caller_u 
            if (leading) {

                it = Erase(it);

            } else {

                stats()->Drop(element);

                stats()->Drop(element.ToLogStatisticsElement());

                element.SetDropped(1);

                if (last.coalesce(&element, 1)) {

                    it = Erase(it, true);

logd/LogBufferElement.cpp

+17 −8
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ LogBufferElement::~LogBufferElement() { 


uint32_t LogBufferElement::GetTag() const {

    // Binary buffers have no tag.

    if (!IsBinary()) {

    if (!IsBinary(log_id())) {

        return 0;

    }
@@ -95,12 +95,21 @@ uint32_t LogBufferElement::GetTag() const { 
        return tag_;

    }



    // For non-dropped messages, we get the tag from the message header itself.

    if (msg_len_ < sizeof(android_event_header_t)) {

        return 0;

    return MsgToTag(msg(), msg_len());

}



    return reinterpret_cast<const android_event_header_t*>(msg_)->tag;

LogStatisticsElement LogBufferElement::ToLogStatisticsElement() const {

    return LogStatisticsElement{

            .uid = uid(),

            .pid = pid(),

            .tid = tid(),

            .tag = GetTag(),

            .realtime = realtime(),

            .msg = msg(),

            .msg_len = msg_len(),

            .dropped_count = dropped_count(),

            .log_id = log_id(),

    };

}



uint16_t LogBufferElement::SetDropped(uint16_t value) {
@@ -218,7 +227,7 @@ size_t LogBufferElement::PopulateDroppedMessage(char*& buffer, LogStatistics* st 
                          type, dropped_count(), (dropped_count() > 1) ? "s" : "");



    size_t hdrLen;

    if (IsBinary()) {

    if (IsBinary(log_id())) {

        hdrLen = sizeof(android_log_event_string_t);

    } else {

        hdrLen = 1 + sizeof(tag);
@@ -232,7 +241,7 @@ size_t LogBufferElement::PopulateDroppedMessage(char*& buffer, LogStatistics* st 
    }



    size_t retval = hdrLen + len;

    if (IsBinary()) {

    if (IsBinary(log_id())) {

        android_log_event_string_t* event =

            reinterpret_cast<android_log_event_string_t*>(buffer);

logd/LogBufferElement.h

+3 −3
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 


#include "LogWriter.h"



class LogStatistics;

#include "LogStatistics.h"



#define EXPIRE_HOUR_THRESHOLD 24  // Only expire chatty UID logs to preserve

                                  // non-chatty UIDs less than this age in hours
@@ -40,13 +40,13 @@ class __attribute__((packed)) LogBufferElement { 
    LogBufferElement(LogBufferElement&& elem);

    ~LogBufferElement();



    bool IsBinary() const { return (log_id_ == LOG_ID_EVENTS) || (log_id_ == LOG_ID_SECURITY); }



    uint32_t GetTag() const;

    uint16_t SetDropped(uint16_t value);



    bool FlushTo(LogWriter* writer, LogStatistics* parent, bool lastSame);



    LogStatisticsElement ToLogStatisticsElement() const;



    log_id_t log_id() const { return static_cast<log_id_t>(log_id_); }

    uid_t uid() const { return uid_; }

    pid_t pid() const { return pid_; }

logd/LogStatistics.cpp

+38 −36
Original line number Diff line number Diff line
@@ -29,6 +29,8 @@ 


#include <private/android_logger.h>



#include "LogBufferElement.h"



static const uint64_t hourSec = 60 * 60;

static const uint64_t monthSec = 31 * 24 * hourSec;
@@ -87,10 +89,10 @@ void LogStatistics::AddTotal(log_id_t log_id, uint16_t size) { 
    ++mElementsTotal[log_id];

}



void LogStatistics::Add(const LogBufferElement& element) {

void LogStatistics::Add(const LogStatisticsElement& element) {

    auto lock = std::lock_guard{lock_};

    log_id_t log_id = element.log_id();

    uint16_t size = element.msg_len();

    log_id_t log_id = element.log_id;

    uint16_t size = element.msg_len;

    mSizes[log_id] += size;

    ++mElements[log_id];
@@ -99,7 +101,7 @@ void LogStatistics::Add(const LogBufferElement& element) { 
    // evaluated and trimmed, thus recording size and number of

    // elements, but we must recognize the manufactured dropped

    // entry as not contributing to the lifetime totals.

    if (element.dropped_count()) {

    if (element.dropped_count) {

        ++mDroppedElements[log_id];

    } else {

        mSizesTotal[log_id] += size;
@@ -107,7 +109,7 @@ void LogStatistics::Add(const LogBufferElement& element) { 
        ++mElementsTotal[log_id];

    }



    log_time stamp(element.realtime());

    log_time stamp(element.realtime);

    if (mNewest[log_id] < stamp) {

        // A major time update invalidates the statistics :-(

        log_time diff = stamp - mNewest[log_id];
@@ -132,19 +134,19 @@ void LogStatistics::Add(const LogBufferElement& element) { 
        return;

    }



    uidTable[log_id].Add(element.uid(), element);

    if (element.uid() == AID_SYSTEM) {

        pidSystemTable[log_id].Add(element.pid(), element);

    uidTable[log_id].Add(element.uid, element);

    if (element.uid == AID_SYSTEM) {

        pidSystemTable[log_id].Add(element.pid, element);

    }



    if (!enable) {

        return;

    }



    pidTable.Add(element.pid(), element);

    tidTable.Add(element.tid(), element);

    pidTable.Add(element.pid, element);

    tidTable.Add(element.tid, element);



    uint32_t tag = element.GetTag();

    uint32_t tag = element.tag;

    if (tag) {

        if (log_id == LOG_ID_SECURITY) {

            securityTagTable.Add(tag, element);
@@ -153,42 +155,42 @@ void LogStatistics::Add(const LogBufferElement& element) { 
        }

    }



    if (!element.dropped_count()) {

    if (!element.dropped_count) {

        tagNameTable.Add(TagNameKey(element), element);

    }

}



void LogStatistics::Subtract(const LogBufferElement& element) {

void LogStatistics::Subtract(const LogStatisticsElement& element) {

    auto lock = std::lock_guard{lock_};

    log_id_t log_id = element.log_id();

    uint16_t size = element.msg_len();

    log_id_t log_id = element.log_id;

    uint16_t size = element.msg_len;

    mSizes[log_id] -= size;

    --mElements[log_id];

    if (element.dropped_count()) {

    if (element.dropped_count) {

        --mDroppedElements[log_id];

    }



    if (mOldest[log_id] < element.realtime()) {

        mOldest[log_id] = element.realtime();

    if (mOldest[log_id] < element.realtime) {

        mOldest[log_id] = element.realtime;

    }



    if (log_id == LOG_ID_KERNEL) {

        return;

    }



    uidTable[log_id].Subtract(element.uid(), element);

    if (element.uid() == AID_SYSTEM) {

        pidSystemTable[log_id].Subtract(element.pid(), element);

    uidTable[log_id].Subtract(element.uid, element);

    if (element.uid == AID_SYSTEM) {

        pidSystemTable[log_id].Subtract(element.pid, element);

    }



    if (!enable) {

        return;

    }



    pidTable.Subtract(element.pid(), element);

    tidTable.Subtract(element.tid(), element);

    pidTable.Subtract(element.pid, element);

    tidTable.Subtract(element.tid, element);



    uint32_t tag = element.GetTag();

    uint32_t tag = element.tag;

    if (tag) {

        if (log_id == LOG_ID_SECURITY) {

            securityTagTable.Subtract(tag, element);
@@ -197,37 +199,37 @@ void LogStatistics::Subtract(const LogBufferElement& element) { 
        }

    }



    if (!element.dropped_count()) {

    if (!element.dropped_count) {

        tagNameTable.Subtract(TagNameKey(element), element);

    }

}



// Atomically set an entry to drop

// entry->setDropped(1) must follow this call, caller should do this explicitly.

void LogStatistics::Drop(const LogBufferElement& element) {

void LogStatistics::Drop(const LogStatisticsElement& element) {

    auto lock = std::lock_guard{lock_};

    log_id_t log_id = element.log_id();

    uint16_t size = element.msg_len();

    log_id_t log_id = element.log_id;

    uint16_t size = element.msg_len;

    mSizes[log_id] -= size;

    ++mDroppedElements[log_id];



    if (mNewestDropped[log_id] < element.realtime()) {

        mNewestDropped[log_id] = element.realtime();

    if (mNewestDropped[log_id] < element.realtime) {

        mNewestDropped[log_id] = element.realtime;

    }



    uidTable[log_id].Drop(element.uid(), element);

    if (element.uid() == AID_SYSTEM) {

        pidSystemTable[log_id].Drop(element.pid(), element);

    uidTable[log_id].Drop(element.uid, element);

    if (element.uid == AID_SYSTEM) {

        pidSystemTable[log_id].Drop(element.pid, element);

    }



    if (!enable) {

        return;

    }



    pidTable.Drop(element.pid(), element);

    tidTable.Drop(element.tid(), element);

    pidTable.Drop(element.pid, element);

    tidTable.Drop(element.tid, element);



    uint32_t tag = element.GetTag();

    uint32_t tag = element.tag;

    if (tag) {

        if (log_id == LOG_ID_SECURITY) {

            securityTagTable.Drop(tag, element);

logd/LogStatistics.h

+70 −61
Original line number Diff line number Diff line
@@ -38,7 +38,6 @@ 
#include <private/android_filesystem_config.h>

#include <utils/FastStrcmp.h>



#include "LogBufferElement.h"

#include "LogUtils.h"



#define log_id_for_each(i) \
@@ -46,6 +45,18 @@ 


class LogStatistics;



struct LogStatisticsElement {

    uid_t uid;

    pid_t pid;

    pid_t tid;

    uint32_t tag;

    log_time realtime;

    const char* msg;

    uint16_t msg_len;

    uint16_t dropped_count;

    log_id_t log_id;

};



template <typename TKey, typename TEntry>

class LogHashtable {

    std::unordered_map<TKey, TEntry> map;
@@ -113,7 +124,7 @@ class LogHashtable { 
        }

    }



    iterator Add(const TKey& key, const LogBufferElement& element) {

    iterator Add(const TKey& key, const LogStatisticsElement& element) {

        iterator it = map.find(key);

        if (it == map.end()) {

            it = map.insert(std::make_pair(key, TEntry(element))).first;
@@ -133,14 +144,14 @@ class LogHashtable { 
        return it;

    }



    void Subtract(const TKey& key, const LogBufferElement& element) {

    void Subtract(const TKey& key, const LogStatisticsElement& element) {

        iterator it = map.find(key);

        if (it != map.end() && it->second.Subtract(element)) {

            map.erase(it);

        }

    }



    void Drop(const TKey& key, const LogBufferElement& element) {

    void Drop(const TKey& key, const LogStatisticsElement& element) {

        iterator it = map.find(key);

        if (it != map.end()) {

            it->second.Drop(element);
@@ -156,13 +167,13 @@ class LogHashtable { 
class EntryBase {

  public:

    EntryBase() : size_(0) {}

    explicit EntryBase(const LogBufferElement& element) : size_(element.msg_len()) {}

    explicit EntryBase(const LogStatisticsElement& element) : size_(element.msg_len) {}



    size_t getSizes() const { return size_; }



    void Add(const LogBufferElement& element) { size_ += element.msg_len(); }

    bool Subtract(const LogBufferElement& element) {

        size_ -= element.msg_len();

    void Add(const LogStatisticsElement& element) { size_ += element.msg_len; }

    bool Subtract(const LogStatisticsElement& element) {

        size_ -= element.msg_len;

        return !size_;

    }
@@ -193,20 +204,20 @@ class EntryBase { 
class EntryBaseDropped : public EntryBase {

  public:

    EntryBaseDropped() : dropped_(0) {}

    explicit EntryBaseDropped(const LogBufferElement& element)

        : EntryBase(element), dropped_(element.dropped_count()) {}

    explicit EntryBaseDropped(const LogStatisticsElement& element)

        : EntryBase(element), dropped_(element.dropped_count) {}



    size_t dropped_count() const { return dropped_; }



    void Add(const LogBufferElement& element) {

        dropped_ += element.dropped_count();

    void Add(const LogStatisticsElement& element) {

        dropped_ += element.dropped_count;

        EntryBase::Add(element);

    }

    bool Subtract(const LogBufferElement& element) {

        dropped_ -= element.dropped_count();

    bool Subtract(const LogStatisticsElement& element) {

        dropped_ -= element.dropped_count;

        return EntryBase::Subtract(element) && !dropped_;

    }

    void Drop(const LogBufferElement& element) {

    void Drop(const LogStatisticsElement& element) {

        dropped_ += 1;

        EntryBase::Subtract(element);

    }
@@ -217,15 +228,15 @@ class EntryBaseDropped : public EntryBase { 


class UidEntry : public EntryBaseDropped {

  public:

    explicit UidEntry(const LogBufferElement& element)

        : EntryBaseDropped(element), uid_(element.uid()), pid_(element.pid()) {}

    explicit UidEntry(const LogStatisticsElement& element)

        : EntryBaseDropped(element), uid_(element.uid), pid_(element.pid) {}



    uid_t key() const { return uid_; }

    uid_t uid() const { return key(); }

    pid_t pid() const { return pid_; }



    void Add(const LogBufferElement& element) {

        if (pid_ != element.pid()) {

    void Add(const LogStatisticsElement& element) {

        if (pid_ != element.pid) {

            pid_ = -1;

        }

        EntryBaseDropped::Add(element);
@@ -250,10 +261,10 @@ class PidEntry : public EntryBaseDropped { 
          pid_(pid),

          uid_(android::pidToUid(pid)),

          name_(android::pidToName(pid)) {}

    explicit PidEntry(const LogBufferElement& element)

    explicit PidEntry(const LogStatisticsElement& element)

        : EntryBaseDropped(element),

          pid_(element.pid()),

          uid_(element.uid()),

          pid_(element.pid),

          uid_(element.uid),

          name_(android::pidToName(pid_)) {}

    PidEntry(const PidEntry& element)

        : EntryBaseDropped(element),
@@ -277,14 +288,14 @@ class PidEntry : public EntryBaseDropped { 
        }

    }



    void Add(const LogBufferElement& element) {

        uid_t incoming_uid = element.uid();

    void Add(const LogStatisticsElement& element) {

        uid_t incoming_uid = element.uid;

        if (uid() != incoming_uid) {

            uid_ = incoming_uid;

            free(name_);

            name_ = android::pidToName(element.pid());

            name_ = android::pidToName(element.pid);

        } else {

            Add(element.pid());

            Add(element.pid);

        }

        EntryBaseDropped::Add(element);

    }
@@ -306,11 +317,11 @@ class TidEntry : public EntryBaseDropped { 
          pid_(pid),

          uid_(android::pidToUid(tid)),

          name_(android::tidToName(tid)) {}

    explicit TidEntry(const LogBufferElement& element)

    explicit TidEntry(const LogStatisticsElement& element)

        : EntryBaseDropped(element),

          tid_(element.tid()),

          pid_(element.pid()),

          uid_(element.uid()),

          tid_(element.tid),

          pid_(element.pid),

          uid_(element.uid),

          name_(android::tidToName(tid_)) {}

    TidEntry(const TidEntry& element)

        : EntryBaseDropped(element),
@@ -336,16 +347,16 @@ class TidEntry : public EntryBaseDropped { 
        }

    }



    void Add(const LogBufferElement& element) {

        uid_t incoming_uid = element.uid();

        pid_t incoming_pid = element.pid();

    void Add(const LogStatisticsElement& element) {

        uid_t incoming_uid = element.uid;

        pid_t incoming_pid = element.pid;

        if (uid() != incoming_uid || pid() != incoming_pid) {

            uid_ = incoming_uid;

            pid_ = incoming_pid;

            free(name_);

            name_ = android::tidToName(element.tid());

            name_ = android::tidToName(element.tid);

        } else {

            Add(element.tid());

            Add(element.tid);

        }

        EntryBaseDropped::Add(element);

    }
@@ -362,22 +373,19 @@ class TidEntry : public EntryBaseDropped { 


class TagEntry : public EntryBaseDropped {

  public:

    explicit TagEntry(const LogBufferElement& element)

        : EntryBaseDropped(element),

          tag_(element.GetTag()),

          pid_(element.pid()),

          uid_(element.uid()) {}

    explicit TagEntry(const LogStatisticsElement& element)

        : EntryBaseDropped(element), tag_(element.tag), pid_(element.pid), uid_(element.uid) {}



    uint32_t key() const { return tag_; }

    pid_t pid() const { return pid_; }

    uid_t uid() const { return uid_; }

    const char* name() const { return android::tagToName(tag_); }



    void Add(const LogBufferElement& element) {

        if (uid_ != element.uid()) {

    void Add(const LogStatisticsElement& element) {

        if (uid_ != element.uid) {

            uid_ = -1;

        }

        if (pid_ != element.pid()) {

        if (pid_ != element.pid) {

            pid_ = -1;

        }

        EntryBaseDropped::Add(element);
@@ -396,9 +404,10 @@ struct TagNameKey { 
    std::string* alloc;

    std::string_view name;  // Saves space if const char*



    explicit TagNameKey(const LogBufferElement& element) : alloc(nullptr), name("", strlen("")) {

        if (element.IsBinary()) {

            uint32_t tag = element.GetTag();

    explicit TagNameKey(const LogStatisticsElement& element)

        : alloc(nullptr), name("", strlen("")) {

        if (IsBinary(element.log_id)) {

            uint32_t tag = element.tag;

            if (tag) {

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

                if (cp) {
@@ -412,13 +421,13 @@ struct TagNameKey { 
            name = std::string_view(alloc->c_str(), alloc->size());

            return;

        }

        const char* msg = element.msg();

        const char* msg = element.msg;

        if (!msg) {

            name = std::string_view("chatty", strlen("chatty"));

            return;

        }

        ++msg;

        uint16_t len = element.msg_len();

        uint16_t len = element.msg_len;

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

        if (!len) {

            name = std::string_view("<NULL>", strlen("<NULL>"));
@@ -480,11 +489,11 @@ struct std::hash<TagNameKey> 


class TagNameEntry : public EntryBase {

  public:

    explicit TagNameEntry(const LogBufferElement& element)

    explicit TagNameEntry(const LogStatisticsElement& element)

        : EntryBase(element),

          tid_(element.tid()),

          pid_(element.pid()),

          uid_(element.uid()),

          tid_(element.tid),

          pid_(element.pid),

          uid_(element.uid),

          name_(element) {}



    const TagNameKey& key() const { return name_; }
@@ -494,14 +503,14 @@ class TagNameEntry : public EntryBase { 
    const char* name() const { return name_.data(); }

    size_t getNameAllocLength() const { return name_.getAllocLength(); }



    void Add(const LogBufferElement& element) {

        if (uid_ != element.uid()) {

    void Add(const LogStatisticsElement& element) {

        if (uid_ != element.uid) {

            uid_ = -1;

        }

        if (pid_ != element.pid()) {

        if (pid_ != element.pid) {

            pid_ = -1;

        }

        if (tid_ != element.tid()) {

        if (tid_ != element.tid) {

            tid_ = -1;

        }

        EntryBase::Add(element);
@@ -590,14 +599,14 @@ class LogStatistics { 
    LogStatistics(bool enable_statistics);



    void AddTotal(log_id_t log_id, uint16_t size) EXCLUDES(lock_);

    void Add(const LogBufferElement& entry) EXCLUDES(lock_);

    void Subtract(const LogBufferElement& entry) EXCLUDES(lock_);

    void Add(const LogStatisticsElement& entry) EXCLUDES(lock_);

    void Subtract(const LogStatisticsElement& entry) EXCLUDES(lock_);

    // entry->setDropped(1) must follow this call

    void Drop(const LogBufferElement& entry) EXCLUDES(lock_);

    void Drop(const LogStatisticsElement& entry) EXCLUDES(lock_);

    // Correct for coalescing two entries referencing dropped content

    void Erase(const LogBufferElement& element) EXCLUDES(lock_) {

    void Erase(const LogStatisticsElement& element) EXCLUDES(lock_) {

        auto lock = std::lock_guard{lock_};

        log_id_t log_id = element.log_id();

        log_id_t log_id = element.log_id;

        --mElements[log_id];

        --mDroppedElements[log_id];

    }