855c7c87a3
ChattyLogBuffer::FlushTo() needs an array of pid_t's to differentiate between deduplication and spam removal chatty messages, but that won't be useful to other log buffers, so it doesn't deserve its own entry in the abstruct LogBuffer::FlushTo() function. Other log buffers may need their own data stored for each reader, so we create an interface that the reader itself owns and passes to the log buffer. It uses a unique_ptr, such that the when the reader is destroyed, so will this state. FlushToState will additionally contain the start point, that it will increment itself and the log mask, which LogBuffers can use to efficiently keep track of the next elements that will be read during a call to FlushTo(). Side benefit: this allows ChattyLogBufferTests to correctly report 'identical' instead of 'expired' lines the deduplication tests. Side benefit #2: This updates LogReaderThread::start() more aggressively, which should result in readers being disconnected less often, particularly readers who read only a certain UID. Test: logging unit tests Change-Id: I969565eb2996afb1431f20e7ccaaa906fcb8f6d1
84 lines
3.3 KiB
C++
84 lines
3.3 KiB
C++
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <atomic>
|
|
#include <list>
|
|
#include <mutex>
|
|
|
|
#include "LogBuffer.h"
|
|
#include "LogBufferElement.h"
|
|
#include "LogReaderList.h"
|
|
#include "LogStatistics.h"
|
|
#include "LogTags.h"
|
|
#include "rwlock.h"
|
|
|
|
class SimpleLogBuffer : public LogBuffer {
|
|
public:
|
|
SimpleLogBuffer(LogReaderList* reader_list, LogTags* tags, LogStatistics* stats);
|
|
~SimpleLogBuffer();
|
|
void Init() override;
|
|
|
|
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;
|
|
std::unique_ptr<FlushToState> CreateFlushToState(uint64_t start, LogMask log_mask) override;
|
|
bool FlushTo(LogWriter* writer, FlushToState& state,
|
|
const std::function<FilterResult(log_id_t log_id, pid_t pid, uint64_t sequence,
|
|
log_time realtime, uint16_t dropped_count)>&
|
|
filter) override;
|
|
|
|
bool Clear(log_id_t id, uid_t uid) override;
|
|
unsigned long GetSize(log_id_t id) override;
|
|
int SetSize(log_id_t id, unsigned long size) override;
|
|
|
|
uint64_t sequence() const override { return sequence_.load(std::memory_order_relaxed); }
|
|
|
|
protected:
|
|
virtual bool Prune(log_id_t id, unsigned long prune_rows, uid_t uid) REQUIRES(lock_);
|
|
virtual void LogInternal(LogBufferElement&& elem) REQUIRES(lock_);
|
|
|
|
// Returns an iterator to the oldest element for a given log type, or logs_.end() if
|
|
// there are no logs for the given log type. Requires logs_lock_ to be held.
|
|
std::list<LogBufferElement>::iterator GetOldest(log_id_t log_id) REQUIRES(lock_);
|
|
std::list<LogBufferElement>::iterator Erase(std::list<LogBufferElement>::iterator it)
|
|
REQUIRES(lock_);
|
|
void KickReader(LogReaderThread* reader, log_id_t id, unsigned long prune_rows)
|
|
REQUIRES_SHARED(lock_);
|
|
|
|
LogStatistics* stats() { return stats_; }
|
|
LogReaderList* reader_list() { return reader_list_; }
|
|
unsigned long max_size(log_id_t id) REQUIRES_SHARED(lock_) { return max_size_[id]; }
|
|
std::list<LogBufferElement>& logs() { return logs_; }
|
|
|
|
RwLock lock_;
|
|
|
|
private:
|
|
bool ShouldLog(log_id_t log_id, const char* msg, uint16_t len);
|
|
void MaybePrune(log_id_t id) REQUIRES(lock_);
|
|
|
|
LogReaderList* reader_list_;
|
|
LogTags* tags_;
|
|
LogStatistics* stats_;
|
|
|
|
std::atomic<uint64_t> sequence_ = 1;
|
|
|
|
unsigned long max_size_[LOG_ID_MAX] GUARDED_BY(lock_);
|
|
std::list<LogBufferElement> logs_ GUARDED_BY(lock_);
|
|
// Keeps track of the iterator to the oldest log message of a given log type, as an
|
|
// optimization when pruning logs. Use GetOldest() to retrieve.
|
|
std::optional<std::list<LogBufferElement>::iterator> oldest_[LOG_ID_MAX] GUARDED_BY(lock_);
|
|
};
|