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

Commit dd0cd8d8 authored by Mark Salyzyn's avatar Mark Salyzyn Committed by Gerrit Code Review
Browse files

Merge changes I96998c4b,I161bf03b 

* changes:
  logd: last iterator initialized incorrectly
  logd: ASAN cleansing
parents 59cebb6e 1f46716f

libutils/include/utils/FastStrcmp.h

+35 −12
Original line number Diff line number Diff line
@@ -17,6 +17,13 @@ 
#ifndef _ANDROID_UTILS_FASTSTRCMP_H__

#define _ANDROID_UTILS_FASTSTRCMP_H__



#include <ctype.h>

#include <string.h>



#ifndef __predict_true

#define __predict_true(exp) __builtin_expect((exp) != 0, 1)

#endif



#ifdef __cplusplus



// Optimized for instruction cache locality
@@ -28,25 +35,41 @@ 
//

//  fastcmp<strncmp>(str1, str2, len)

//

// NB: Does not work for the case insensitive str*cmp functions.

// NB: use fasticmp for the case insensitive str*cmp functions.

// NB: Returns boolean, do not use if expecting to check negative value.

//     Thus not semantically identical to the expected function behavior.



template <int (*cmp)(const char* l, const char* r, const size_t s)>

static inline int fastcmp(const char* l, const char* r, const size_t s) {

    return (*l != *r) || cmp(l + 1, r + 1, s - 1);

    const ssize_t n = s;  // To help reject negative sizes, treat like zero

    return __predict_true(n > 0) &&

           ((*l != *r) || (__predict_true(n > 1) && cmp(l + 1, r + 1, n - 1)));

}



template <int (*cmp)(const char* l, const char* r, const size_t s)>

static inline int fasticmp(const char* l, const char* r, const size_t s) {

    const ssize_t n = s;  // To help reject negative sizes, treat like zero

    return __predict_true(n > 0) &&

           ((tolower(*l) != tolower(*r)) || (__predict_true(n > 1) && cmp(l + 1, r + 1, n - 1)));

}



template <int (*cmp)(const void* l, const void* r, const size_t s)>

static inline int fastcmp(const void* lv, const void* rv, const size_t s) {

    const char* l = static_cast<const char*>(lv);

    const char* r = static_cast<const char*>(rv);

    return (*l != *r) || cmp(l + 1, r + 1, s - 1);

    const ssize_t n = s;  // To help reject negative sizes, treat like zero

    return __predict_true(n > 0) &&

           ((*l != *r) || (__predict_true(n > 1) && cmp(l + 1, r + 1, n - 1)));

}



template <int (*cmp)(const char* l, const char* r)>

static inline int fastcmp(const char* l, const char* r) {

    return (*l != *r) || cmp(l + 1, r + 1);

    return (*l != *r) || (__predict_true(*l) && cmp(l + 1, r + 1));

}



template <int (*cmp)(const char* l, const char* r)>

static inline int fasticmp(const char* l, const char* r) {

    return (tolower(*l) != tolower(*r)) || (__predict_true(*l) && cmp(l + 1, r + 1));

}



#endif

logd/LogBuffer.cpp

+8 −12
Original line number Diff line number Diff line
@@ -132,11 +132,11 @@ static enum match_type identical(LogBufferElement* elem, 
                                 LogBufferElement* last) {

    // is it mostly identical?

    //  if (!elem) return DIFFERENT;

    unsigned short lenl = elem->getMsgLen();

    if (!lenl) return DIFFERENT;

    ssize_t lenl = elem->getMsgLen();

    if (lenl <= 0) return DIFFERENT;  // value if this represents a chatty elem

    //  if (!last) return DIFFERENT;

    unsigned short lenr = last->getMsgLen();

    if (!lenr) return DIFFERENT;

    ssize_t lenr = last->getMsgLen();

    if (lenr <= 0) return DIFFERENT;  // value if this represents a chatty elem

    //  if (elem->getLogId() != last->getLogId()) return DIFFERENT;

    if (elem->getUid() != last->getUid()) return DIFFERENT;

    if (elem->getPid() != last->getPid()) return DIFFERENT;
@@ -162,8 +162,6 @@ static enum match_type identical(LogBufferElement* elem, 
    }



    // audit message (except sequence number) identical?

    static const char avc[] = "): avc: ";



    if (last->isBinary()) {

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

                                            sizeof(int32_t)))
@@ -173,6 +171,7 @@ static enum match_type identical(LogBufferElement* elem, 
        msgr += sizeof(android_log_event_string_t);

        lenr -= sizeof(android_log_event_string_t);

    }

    static const char avc[] = "): avc: ";

    const char* avcl = android::strnstr(msgl, lenl, avc);

    if (!avcl) return DIFFERENT;

    lenl -= avcl - msgl;
@@ -180,10 +179,7 @@ static enum match_type identical(LogBufferElement* elem, 
    if (!avcr) return DIFFERENT;

    lenr -= avcr - msgr;

    if (lenl != lenr) return DIFFERENT;

    // TODO: After b/35468874 is addressed, revisit "lenl > strlen(avc)"

    // condition, it might become superfluous.

    if (lenl > strlen(avc) &&

        fastcmp<memcmp>(avcl + strlen(avc), avcr + strlen(avc),

    if (fastcmp<memcmp>(avcl + strlen(avc), avcr + strlen(avc),

                        lenl - strlen(avc))) {

        return DIFFERENT;

    }
@@ -1092,12 +1088,12 @@ log_time LogBuffer::flushTo( 
        // client wants to start from the beginning

        it = mLogElements.begin();

    } else {

        LogBufferElementCollection::iterator last = mLogElements.begin();

        LogBufferElementCollection::iterator last;

        // 30 second limit to continue search for out-of-order entries.

        log_time min = start - log_time(30, 0);

        // Client wants to start from some specified time. Chances are

        // we are better off starting from the end of the time sorted list.

        for (it = mLogElements.end(); it != mLogElements.begin();

        for (last = it = mLogElements.end(); it != mLogElements.begin();

             /* do nothing */) {

            --it;

            LogBufferElement* element = *it;

logd/LogKlog.cpp

+154 −175

File changed.

Preview size limit exceeded, changes collapsed.

logd/LogKlog.h

+5 −7
Original line number Diff line number Diff line
@@ -20,8 +20,6 @@ 
#include <private/android_logger.h>

#include <sysutils/SocketListener.h>



char* log_strntok_r(char* s, size_t* len, char** saveptr, size_t* sublen);



class LogBuffer;

class LogReader;
@@ -43,8 +41,8 @@ class LogKlog : public SocketListener { 
   public:

    LogKlog(LogBuffer* buf, LogReader* reader, int fdWrite, int fdRead,

            bool auditd);

    int log(const char* buf, size_t len);

    void synchronize(const char* buf, size_t len);

    int log(const char* buf, ssize_t len);

    void synchronize(const char* buf, ssize_t len);



    bool isMonotonic() {

        return logbuf->isMonotonic();
@@ -57,10 +55,10 @@ class LogKlog : public SocketListener { 
    }



   protected:

    void sniffTime(log_time& now, const char** buf, size_t len, bool reverse);

    pid_t sniffPid(const char** buf, size_t len);

    void sniffTime(log_time& now, const char*& buf, ssize_t len, bool reverse);

    pid_t sniffPid(const char*& buf, ssize_t len);

    void calculateCorrection(const log_time& monotonic, const char* real_string,

                             size_t len);

                             ssize_t len);

    virtual bool onDataAvailable(SocketClient* cli);

};

logd/LogUtils.h

+19 −2
Original line number Diff line number Diff line
@@ -43,8 +43,25 @@ char* tidToName(pid_t tid); 
const char* tagToName(uint32_t tag);

void ReReadEventLogTags();



// Furnished by LogKlog.cpp.

const char* strnstr(const char* s, size_t len, const char* needle);

// Furnished by LogKlog.cpp

char* log_strntok_r(char* s, ssize_t& len, char*& saveptr, ssize_t& sublen);



// needle should reference a string longer than 1 character

static inline const char* strnstr(const char* s, ssize_t len,

                                  const char* needle) {

    if (len <= 0) return nullptr;



    const char c = *needle++;

    const size_t needleLen = strlen(needle);

    do {

        do {

            if (len <= (ssize_t)needleLen) return nullptr;

            --len;

        } while (*s++ != c);

    } while (fastcmp<memcmp>(s, needle, needleLen));

    s--;

    return s;

}

}



// Furnished in LogCommand.cpp