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

Commit 283c9a1c authored by Tom Cherry's avatar Tom Cherry
Browse files

logd: remove SocketClient from LogBuffer and LogBufferElement 

In the future, we'll want to be able to write to outputs that are not
necessarily a libsysutils SocketClient, for example host tests of
LogBuffer.  Therefore, we add a LogWriter class to be used instead of
SocketClient.

Test: logging unit tests
Change-Id: I4385be65e14e83a635691a7ba79e9bf060e49484
parent 0b3f9567

logd/ChattyLogBuffer.cpp

+13 −16
Original line number Diff line number Diff line
@@ -34,8 +34,6 @@ 
#include <cutils/properties.h>

#include <private/android_logger.h>



#include "LogKlog.h"

#include "LogReader.h"

#include "LogUtils.h"



#ifndef __predict_false
@@ -494,8 +492,8 @@ void ChattyLogBuffer::kickMe(LogReaderThread* me, log_id_t id, unsigned long pru 
    if (stats_->Sizes(id) > (2 * log_buffer_size(id))) {  // +100%

        // A misbehaving or slow reader has its connection

        // dropped if we hit too much memory pressure.

        android::prdebug("Kicking blocked reader, pid %d, from ChattyLogBuffer::kickMe()\n",

                         me->client()->getPid());

        android::prdebug("Kicking blocked reader, %s, from ChattyLogBuffer::kickMe()\n",

                         me->name().c_str());

        me->release_Locked();

    } else if (me->deadline().time_since_epoch().count() != 0) {

        // Allow a blocked WRAP deadline reader to trigger and start reporting the log data.
@@ -503,8 +501,8 @@ void ChattyLogBuffer::kickMe(LogReaderThread* me, log_id_t id, unsigned long pru 
    } else {

        // tell slow reader to skip entries to catch up

        android::prdebug(

                "Skipping %lu entries from slow reader, pid %d, from ChattyLogBuffer::kickMe()\n",

                pruneRows, me->client()->getPid());

                "Skipping %lu entries from slow reader, %s, from ChattyLogBuffer::kickMe()\n",

                pruneRows, me->name().c_str());

        me->triggerSkip_Locked(id, pruneRows);

    }

}
@@ -872,8 +870,8 @@ bool ChattyLogBuffer::Clear(log_id_t id, uid_t uid) { 
                for (const auto& reader_thread : reader_list_->reader_threads()) {

                    if (reader_thread->IsWatching(id)) {

                        android::prdebug(

                                "Kicking blocked reader, pid %d, from ChattyLogBuffer::clear()\n",

                                reader_thread->client()->getPid());

                                "Kicking blocked reader, %s, from ChattyLogBuffer::clear()\n",

                                reader_thread->name().c_str());

                        reader_thread->release_Locked();

                    }

                }
@@ -911,10 +909,10 @@ unsigned long ChattyLogBuffer::GetSize(log_id_t id) { 
}



uint64_t ChattyLogBuffer::FlushTo(

        SocketClient* reader, uint64_t start, pid_t* lastTid, bool privileged, bool security,

        LogWriter* writer, uint64_t start, pid_t* lastTid,

        const std::function<FlushToResult(const LogBufferElement* element)>& filter) {

    LogBufferElementCollection::iterator it;

    uid_t uid = reader->getUid();

    uid_t uid = writer->uid();



    rdlock();
@@ -940,11 +938,11 @@ uint64_t ChattyLogBuffer::FlushTo( 
    for (; it != mLogElements.end(); ++it) {

        LogBufferElement* element = *it;



        if (!privileged && (element->getUid() != uid)) {

        if (!writer->privileged() && element->getUid() != uid) {

            continue;

        }



        if (!security && (element->getLogId() == LOG_ID_SECURITY)) {

        if (!writer->can_read_security_logs() && element->getLogId() == LOG_ID_SECURITY) {

            continue;

        }
@@ -973,11 +971,10 @@ uint64_t ChattyLogBuffer::FlushTo( 


        unlock();



        curr = element->getSequence();

        // range locking in LastLogTimes looks after us

        curr = element->flushTo(reader, stats_, sameTid);



        if (curr == element->FLUSH_ERROR) {

            return curr;

        if (!element->FlushTo(writer, stats_, sameTid)) {

            return FLUSH_ERROR;

        }



        rdlock();

logd/ChattyLogBuffer.h

+4 −4
Original line number Diff line number Diff line
@@ -28,15 +28,15 @@ 


#include "LogBuffer.h"

#include "LogBufferElement.h"

#include "LogReaderList.h"

#include "LogReaderThread.h"

#include "LogStatistics.h"

#include "LogTags.h"

#include "LogWhiteBlackList.h"

#include "LogWriter.h"



typedef std::list<LogBufferElement*> LogBufferElementCollection;



class LogReaderList;

class LogReaderThread;



class ChattyLogBuffer : public LogBuffer {

    LogBufferElementCollection mLogElements;

    pthread_rwlock_t mLogElementsLock;
@@ -63,7 +63,7 @@ class ChattyLogBuffer : public LogBuffer { 
    int Log(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid, pid_t tid, const char* msg,

            uint16_t len) override;

    uint64_t FlushTo(

            SocketClient* writer, uint64_t start, pid_t* lastTid, bool privileged, bool security,

            LogWriter* writer, uint64_t start, pid_t* lastTid,

            const std::function<FlushToResult(const LogBufferElement* element)>& filter) override;



    bool Clear(log_id_t id, uid_t uid = AID_ROOT) override;

logd/CommandListener.h

+0 −1
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ 
#include "LogBuffer.h"

#include "LogCommand.h"

#include "LogListener.h"

#include "LogReader.h"

#include "LogStatistics.h"

#include "LogTags.h"

#include "LogWhiteBlackList.h"

logd/LogBuffer.h

+4 −2
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ 


#include "LogBufferElement.h"



class LogWriter;



enum class FlushToResult {

    kSkip,

    kStop,
@@ -42,10 +44,10 @@ class LogBuffer { 
    // lastTid is an optional context to help detect if the last previous

    // valid message was from the same source so we can differentiate chatty

    // filter types (identical or expired)

    static const uint64_t FLUSH_ERROR = 0;

    virtual uint64_t FlushTo(

            SocketClient* writer, uint64_t start,

            LogWriter* writer, uint64_t start,

            pid_t* last_tid,  // nullable

            bool privileged, bool security,

            const std::function<FlushToResult(const LogBufferElement* element)>& filter) = 0;



    virtual bool Clear(log_id_t id, uid_t uid) = 0;

logd/LogBufferElement.cpp

+6 −13
Original line number Diff line number Diff line
@@ -28,11 +28,9 @@ 
#include <private/android_logger.h>



#include "LogCommand.h"

#include "LogReader.h"

#include "LogStatistics.h"

#include "LogUtils.h"



const uint64_t LogBufferElement::FLUSH_ERROR(0);

atomic_int_fast64_t LogBufferElement::sequence(1);



LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid,
@@ -243,7 +241,7 @@ size_t LogBufferElement::populateDroppedMessage(char*& buffer, LogStatistics* st 
    return retval;

}



uint64_t LogBufferElement::flushTo(SocketClient* reader, LogStatistics* stats, bool lastSame) {

bool LogBufferElement::FlushTo(LogWriter* writer, LogStatistics* stats, bool lastSame) {

    struct logger_entry entry = {};



    entry.hdr_size = sizeof(struct logger_entry);
@@ -254,23 +252,18 @@ uint64_t LogBufferElement::flushTo(SocketClient* reader, LogStatistics* stats, b 
    entry.sec = mRealTime.tv_sec;

    entry.nsec = mRealTime.tv_nsec;



    struct iovec iovec[2];

    iovec[0].iov_base = &entry;

    iovec[0].iov_len = entry.hdr_size;



    char* buffer = nullptr;



    const char* msg;

    if (mDropped) {

        entry.len = populateDroppedMessage(buffer, stats, lastSame);

        if (!entry.len) return mSequence;

        iovec[1].iov_base = buffer;

        if (!entry.len) return true;

        msg = buffer;

    } else {

        msg = mMsg;

        entry.len = mMsgLen;

        iovec[1].iov_base = mMsg;

    }

    iovec[1].iov_len = entry.len;



    uint64_t retval = reader->sendDatav(iovec, 1 + (entry.len != 0)) ? FLUSH_ERROR : mSequence;

    bool retval = writer->Write(entry, msg);



    if (buffer) free(buffer);