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

Commit bc72197b authored by Tom Cherry's avatar Tom Cherry
Browse files

logd: use the compressed (serialized) log buffer by default 

The serialized log buffer along with compression results in:
* ~3.5x more logs than chatty
* Less CPU usage
* Less memory usage
* Equivalent log range

Also, delete tests that assume that the device logd implementation is
chatty.  There are actual unit tests for this same behavior that don't
rely on the device logd.

Test: serialized log buffer is used
Change-Id: Ie12898617429a75b6caff92725aa7145650f8fc6
parent dfdc9b10

logd/logd_test.cpp

+0 −124
Original line number Diff line number Diff line
@@ -832,127 +832,3 @@ TEST(logd, getEventTag_newentry) { 
    GTEST_LOG_(INFO) << "This test does nothing.\n";

#endif

}
 


#ifdef __ANDROID__

static inline uint32_t get4LE(const uint8_t* src) {

  return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);

}



static inline uint32_t get4LE(const char* src) {

  return get4LE(reinterpret_cast<const uint8_t*>(src));

}

#endif



void __android_log_btwrite_multiple__helper(int count) {

#ifdef __ANDROID__

    log_time ts(CLOCK_MONOTONIC);

    usleep(100);

    log_time ts1(CLOCK_MONOTONIC);



    // We fork to create a unique pid for the submitted log messages

    // so that we do not collide with the other _multiple_ tests.



    pid_t pid = fork();



    if (pid == 0) {

        // child

        for (int i = count; i; --i) {

            ASSERT_LT(

                0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));

            usleep(100);

        }

        ASSERT_LT(0,

                  __android_log_btwrite(0, EVENT_TYPE_LONG, &ts1, sizeof(ts1)));

        usleep(1000000);



        _exit(0);

    }



    siginfo_t info = {};

    ASSERT_EQ(0, TEMP_FAILURE_RETRY(waitid(P_PID, pid, &info, WEXITED)));

    ASSERT_EQ(0, info.si_status);



    struct logger_list* logger_list;

    ASSERT_TRUE(nullptr != (logger_list = android_logger_list_open(LOG_ID_EVENTS,

                                                                   ANDROID_LOG_NONBLOCK, 0, pid)));



    int expected_count = (count < 2) ? count : 2;

    int expected_chatty_count = (count <= 2) ? 0 : 1;

    int expected_identical_count = (count < 2) ? 0 : (count - 2);

    static const int expected_expire_count = 0;



    count = 0;

    int second_count = 0;

    int chatty_count = 0;

    int identical_count = 0;

    int expire_count = 0;



    for (;;) {

        log_msg log_msg;

        if (android_logger_list_read(logger_list, &log_msg) <= 0) break;



        if ((log_msg.entry.pid != pid) || (log_msg.entry.len < (4 + 1 + 8)) ||

            (log_msg.id() != LOG_ID_EVENTS))

            continue;



        char* eventData = log_msg.msg();

        if (!eventData) continue;



        uint32_t tag = get4LE(eventData);



        if ((eventData[4] == EVENT_TYPE_LONG) &&

            (log_msg.entry.len == (4 + 1 + 8))) {

            if (tag != 0) continue;



            log_time* tx = reinterpret_cast<log_time*>(eventData + 4 + 1);

            if (ts == *tx) {

                ++count;

            } else if (ts1 == *tx) {

                ++second_count;

            }

        } else if (eventData[4] == EVENT_TYPE_STRING) {

            if (tag != CHATTY_LOG_TAG) continue;

            ++chatty_count;

            // int len = get4LE(eventData + 4 + 1);

            log_msg.buf[LOGGER_ENTRY_MAX_LEN] = '\0';

            const char* cp;

            if ((cp = strstr(eventData + 4 + 1 + 4, " identical "))) {

                unsigned val = 0;

                sscanf(cp, " identical %u lines", &val);

                identical_count += val;

            } else if ((cp = strstr(eventData + 4 + 1 + 4, " expire "))) {

                unsigned val = 0;

                sscanf(cp, " expire %u lines", &val);

                expire_count += val;

            }

        }

    }



    android_logger_list_close(logger_list);



    EXPECT_EQ(expected_count, count);

    EXPECT_EQ(1, second_count);

    EXPECT_EQ(expected_chatty_count, chatty_count);

    EXPECT_EQ(expected_identical_count, identical_count);

    EXPECT_EQ(expected_expire_count, expire_count);

#else

    count = 0;

    GTEST_LOG_(INFO) << "This test does nothing.\n";

#endif

}



TEST(logd, multiple_test_1) {

    __android_log_btwrite_multiple__helper(1);

}



TEST(logd, multiple_test_2) {

    __android_log_btwrite_multiple__helper(2);

}



TEST(logd, multiple_test_3) {

    __android_log_btwrite_multiple__helper(3);

}



TEST(logd, multiple_test_10) {

    __android_log_btwrite_multiple__helper(10);

}

logd/main.cpp

+1 −1
Original line number Diff line number Diff line
@@ -258,7 +258,7 @@ int main(int argc, char* argv[]) { 
    // Pruning configuration.

    PruneList prune_list;



    std::string buffer_type = GetProperty("logd.buffer_type", "chatty");

    std::string buffer_type = GetProperty("logd.buffer_type", "serialized");



    // Partial (required for chatty) or full logging statistics.

    bool enable_full_log_statistics = __android_logger_property_get_bool(