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

Commit 720f6d1d authored by Mark Salyzyn's avatar Mark Salyzyn
Browse files

logd: Add Pid statistics 

- Optional class of statistics for PID
- Enhance pidToName
- Enhanced uidToName
- Enhance pidToUid
- template sort and iteration

Bug: 19608965
Change-Id: I04a1f02e9851b62987f9b176908134e455f22d1d
parent e322ae19

logd/LogBuffer.cpp

+2 −4
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 


#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/user.h>

#include <time.h>
@@ -281,15 +280,14 @@ void LogBuffer::prune(log_id_t id, unsigned long pruneRows, uid_t caller_uid) { 
        size_t second_worst_sizes = 0;



        if ((id != LOG_ID_CRASH) && mPrune.worstUidEnabled()) {

            const UidEntry **sorted = stats.sort(2, id);

            std::unique_ptr<const UidEntry *[]> sorted = stats.sort(2, id);



            if (sorted) {

            if (sorted.get()) {

                if (sorted[0] && sorted[1]) {

                    worst = sorted[0]->getKey();

                    worst_sizes = sorted[0]->getSizes();

                    second_worst_sizes = sorted[1]->getSizes();

                }

                delete [] sorted;

            }

        }

logd/LogStatistics.cpp

+166 −50
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#include <algorithm> // std::max

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>
@@ -27,7 +26,8 @@ 


#include "LogStatistics.h"



LogStatistics::LogStatistics() {

LogStatistics::LogStatistics()

        : enable(false) {

    log_id_for_each(id) {

        mSizes[id] = 0;

        mElements[id] = 0;
@@ -36,8 +36,10 @@ LogStatistics::LogStatistics() { 
    }

}



namespace android {



// caller must own and free character string

char *LogStatistics::pidToName(pid_t pid) {

static char *pidToName(pid_t pid) {

    char *retval = NULL;

    if (pid == 0) { // special case from auditd for kernel

        retval = strdup("logd.auditd");
@@ -60,6 +62,8 @@ char *LogStatistics::pidToName(pid_t pid) { 
    return retval;

}



}



void LogStatistics::add(LogBufferElement *e) {

    log_id_t log_id = e->getLogId();

    unsigned short size = e->getMsgLen();
@@ -81,6 +85,31 @@ void LogStatistics::add(LogBufferElement *e) { 


    mSizesTotal[log_id] += size;

    ++mElementsTotal[log_id];



    if (!enable) {

        return;

    }



    pid_t pid = e->getPid();

    hash = android::hash_type(pid);

    index = pidTable.find(-1, hash, pid);

    if (index == -1) {

        PidEntry initEntry(pid, uid, android::pidToName(pid));

        initEntry.add(size);

        pidTable.add(hash, initEntry);

    } else {

        PidEntry &entry = pidTable.editEntryAt(index);

        if (entry.getUid() != uid) {

            entry.setUid(uid);

            entry.setName(android::pidToName(pid));

        } else if (!entry.getName()) {

            char *name = android::pidToName(pid);

            if (name) {

                entry.setName(name);

            }

        }

        entry.add(size);

    }

}



void LogStatistics::subtract(LogBufferElement *e) {
@@ -99,33 +128,20 @@ void LogStatistics::subtract(LogBufferElement *e) { 
            table.removeAt(index);

        }

    }

}



// caller must own and delete UidEntry array

const UidEntry **LogStatistics::sort(size_t n, log_id id) {

    if (!n) {

        return NULL;

    if (!enable) {

        return;

    }



    const UidEntry **retval = new const UidEntry* [n];

    memset(retval, 0, sizeof(*retval) * n);



    uidTable_t &table = uidTable[id];

    ssize_t index = -1;

    while ((index = table.next(index)) >= 0) {

        const UidEntry &entry = table.entryAt(index);

        size_t s = entry.getSizes();

        ssize_t i = n - 1;

        while ((!retval[i] || (s > retval[i]->getSizes())) && (--i >= 0));

        if (++i < (ssize_t)n) {

            size_t b = n - i - 1;

            if (b) {

                memmove(&retval[i+1], &retval[i], b * sizeof(retval[0]));

            }

            retval[i] = &entry;

    pid_t pid = e->getPid();

    hash = android::hash_type(pid);

    index = pidTable.find(-1, hash, pid);

    if (index != -1) {

        PidEntry &entry = pidTable.editEntryAt(index);

        if (entry.subtract(size)) {

            pidTable.removeAt(index);

        }

    }

    return retval;

}



// caller must own and free character string
@@ -145,9 +161,30 @@ char *LogStatistics::uidToName(uid_t uid) { 
        ++info;

    }



    // No one

    char *name = NULL;



    // report uid -> pid(s) -> pidToName if unique

    ssize_t index = -1;

    while ((index = pidTable.next(index)) != -1) {

        const PidEntry &entry = pidTable.entryAt(index);



        if (entry.getUid() == uid) {

            const char *n = entry.getName();



            if (n) {

                if (!name) {

                    name = strdup(n);

                } else if (strcmp(name, n)) {

                    free(name);

                    return NULL;

                }

            }

        }

    }



    // No one

    return name;

}



static void format_line(android::String8 &output,

        android::String8 &name, android::String8 &size) {
@@ -223,37 +260,23 @@ void LogStatistics::format(char **buf, uid_t uid, unsigned int logMask) { 
    // Report on Chattiest



    // Chattiest by application (UID)

    static const size_t maximum_sorted_entries = 32;

    log_id_for_each(id) {

        if (!(logMask & (1 << id))) {

            continue;

        }



        static const size_t maximum_sorted_entries = 32;

        const UidEntry **sorted = sort(maximum_sorted_entries, id);



        if (!sorted) {

            continue;

        }



        bool print = false;

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

        bool headerPrinted = false;

        std::unique_ptr<const UidEntry *[]> sorted = sort(maximum_sorted_entries, id);

        ssize_t index = -1;

        while ((index = uidTable_t::next(index, sorted, maximum_sorted_entries)) >= 0) {

            const UidEntry *entry = sorted[index];



            if (!entry) {

                break;

            }



            size_t sizes = entry->getSizes();

            if (sizes < (65536/100)) {

                break;

            }



            uid_t u = entry->getKey();

            if ((uid != AID_ROOT) && (u != uid)) {

                continue;

            }



            if (!print) {

            if (!headerPrinted) {

                if (uid == AID_ROOT) {

                    output.appendFormat(

                        "\n\nChattiest UIDs in %s:\n",
@@ -266,7 +289,7 @@ void LogStatistics::format(char **buf, uid_t uid, unsigned int logMask) { 
                        "\n\nLogging for your UID in %s:\n",

                        android_log_id_to_name(id));

                }

                print = true;

                headerPrinted = true;

            }



            android::String8 name("");
@@ -278,18 +301,62 @@ void LogStatistics::format(char **buf, uid_t uid, unsigned int logMask) { 
            }



            android::String8 size("");

            size.appendFormat("%zu", sizes);

            size.appendFormat("%zu", entry->getSizes());



            format_line(output, name, size);

        }

    }



        delete [] sorted;

    if (enable) {

        bool headerPrinted = false;

        std::unique_ptr<const PidEntry *[]> sorted = pidTable.sort(maximum_sorted_entries);

        ssize_t index = -1;

        while ((index = pidTable.next(index, sorted, maximum_sorted_entries)) >= 0) {

            const PidEntry *entry = sorted[index];

            uid_t u = entry->getUid();

            if ((uid != AID_ROOT) && (u != uid)) {

                continue;

            }



            if (!headerPrinted) {

                if (uid == AID_ROOT) {

                    output.appendFormat("\n\nChattiest PIDs:\n");

                } else {

                    output.appendFormat("\n\nLogging for this PID:\n");

                }

                android::String8 name("  PID/UID");

                android::String8 size("Size");

                android::String8 pruned("Pruned");

                format_line(output, name, size, pruned);

                headerPrinted = true;

            }



            android::String8 name("");

            name.appendFormat("%5u/%u", entry->getKey(), u);

            const char *n = entry->getName();

            if (n) {

                name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", n);

            } else {

                char *un = uidToName(u);

                if (un) {

                    name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", un);

                    free(un);

                }

            }



            android::String8 size("");

            size.appendFormat("%zu", entry->getSizes());



            format_line(output, name, size);

        }

    }



    *buf = strdup(output.string());

}



uid_t LogStatistics::pidToUid(pid_t pid) {

namespace android {



uid_t pidToUid(pid_t pid) {

    char buffer[512];

    snprintf(buffer, sizeof(buffer), "/proc/%u/status", pid);

    FILE *fp = fopen(buffer, "r");
@@ -305,3 +372,52 @@ uid_t LogStatistics::pidToUid(pid_t pid) { 
    }

    return getuid(); // associate this with the logger

}



}



uid_t LogStatistics::pidToUid(pid_t pid) {

    uid_t uid;

    android::hash_t hash = android::hash_type(pid);

    ssize_t index = pidTable.find(-1, hash, pid);

    if (index == -1) {

        uid = android::pidToUid(pid);

        PidEntry initEntry(pid, uid, android::pidToName(pid));

        pidTable.add(hash, initEntry);

    } else {

        PidEntry &entry = pidTable.editEntryAt(index);

        if (!entry.getName()) {

            char *name = android::pidToName(pid);

            if (name) {

                entry.setName(name);

            }

        }

        uid = entry.getUid();

    }

    return uid;

}



// caller must free character string

char *LogStatistics::pidToName(pid_t pid) {

    char *name;



    android::hash_t hash = android::hash_type(pid);

    ssize_t index = pidTable.find(-1, hash, pid);

    if (index == -1) {

        name = android::pidToName(pid);

        PidEntry initEntry(pid, android::pidToUid(pid), name ? strdup(name) : NULL);

        pidTable.add(hash, initEntry);

    } else {

        PidEntry &entry = pidTable.editEntryAt(index);

        const char *n = entry.getName();

        if (n) {

            name = strdup(n);

        } else {

            name = android::pidToName(pid);

            if (name) {

                entry.setName(strdup(name));

            }

        }

    }



    return name;

}

logd/LogStatistics.h

+80 −4
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
#ifndef _LOGD_LOG_STATISTICS_H__

#define _LOGD_LOG_STATISTICS_H__



#include <memory>

#include <stdlib.h>

#include <sys/types.h>



#include <log/log.h>
@@ -27,6 +29,52 @@ 
#define log_id_for_each(i) \

    for (log_id_t i = LOG_ID_MIN; i < LOG_ID_MAX; i = (log_id_t) (i + 1))



template <typename TKey, typename TEntry>

class LogHashtable : public android::BasicHashtable<TKey, TEntry> {

public:

    std::unique_ptr<const TEntry *[]> sort(size_t n) {

        if (!n) {

            std::unique_ptr<const TEntry *[]> sorted(NULL);

            return sorted;

        }



        const TEntry **retval = new const TEntry* [n];

        memset(retval, 0, sizeof(*retval) * n);



        ssize_t index = -1;

        while ((index = android::BasicHashtable<TKey, TEntry>::next(index)) >= 0) {

            const TEntry &entry = android::BasicHashtable<TKey, TEntry>::entryAt(index);

            size_t s = entry.getSizes();

            ssize_t i = n - 1;

            while ((!retval[i] || (s > retval[i]->getSizes())) && (--i >= 0))

                ;

            if (++i < (ssize_t)n) {

                size_t b = n - i - 1;

                if (b) {

                    memmove(&retval[i+1], &retval[i], b * sizeof(retval[0]));

                }

                retval[i] = &entry;

            }

        }

        std::unique_ptr<const TEntry *[]> sorted(retval);

        return sorted;

    }



    // Iteration handler for the sort method output

    static ssize_t next(ssize_t index, std::unique_ptr<const TEntry *[]> &sorted, size_t n) {

        ++index;

        if (!sorted.get() || (index < 0) || (n <= (size_t)index) || !sorted[index]

         || (sorted[index]->getSizes() <= (sorted[0]->getSizes() / 100))) {

            return -1;

        }

        return index;

    }



    ssize_t next(ssize_t index) {

        return android::BasicHashtable<TKey, TEntry>::next(index);

    }

};



struct UidEntry {

    const uid_t uid;

    size_t size;
@@ -39,27 +87,55 @@ struct UidEntry { 
    inline bool subtract(size_t s) { size -= s; return !size; }

};



struct PidEntry {

    const pid_t pid;

    uid_t uid;

    char *name;

    size_t size;



    PidEntry(pid_t p, uid_t u, char *n):pid(p),uid(u),name(n),size(0) { }

    PidEntry(const PidEntry &c):

        pid(c.pid),

        uid(c.uid),

        name(c.name ? strdup(c.name) : NULL),

        size(c.size) { }

    ~PidEntry() { free(name); }



    const pid_t&getKey() const { return pid; }

    const uid_t&getUid() const { return uid; }

    uid_t&setUid(uid_t u) { return uid = u; }

    const char*getName() const { return name; }

    char *setName(char *n) { free(name); return name = n; }

    size_t getSizes() const { return size; }

    inline void add(size_t s) { size += s; }

    inline bool subtract(size_t s) { size -= s; return !size; }

};



// Log Statistics

class LogStatistics {

    size_t mSizes[LOG_ID_MAX];

    size_t mElements[LOG_ID_MAX];

    size_t mSizesTotal[LOG_ID_MAX];

    size_t mElementsTotal[LOG_ID_MAX];

    bool enable;



    // uid to size list

    typedef android::BasicHashtable<uid_t, UidEntry> uidTable_t;

    typedef LogHashtable<uid_t, UidEntry> uidTable_t;

    uidTable_t uidTable[LOG_ID_MAX];



    // pid to uid list

    typedef LogHashtable<pid_t, PidEntry> pidTable_t;

    pidTable_t pidTable;



public:

    LogStatistics();



    void enableStatistics() { }

    void enableStatistics() { enable = true; }



    void add(LogBufferElement *entry);

    void subtract(LogBufferElement *entry);



    // Caller must delete array

    const UidEntry **sort(size_t n, log_id i);

    std::unique_ptr<const UidEntry *[]> sort(size_t n, log_id i) { return uidTable[i].sort(n); }



    // fast track current value by id only

    size_t sizes(log_id_t id) const { return mSizes[id]; }