You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
107 lines
3.7 KiB
107 lines
3.7 KiB
/*
|
|
* 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 <sys/types.h>
|
|
|
|
#include <list>
|
|
#include <vector>
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
#include "LogWriter.h"
|
|
#include "LogdLock.h"
|
|
#include "SerializedData.h"
|
|
#include "SerializedLogEntry.h"
|
|
|
|
class SerializedFlushToState;
|
|
|
|
class SerializedLogChunk {
|
|
public:
|
|
friend void VerifyChunks(const std::list<SerializedLogChunk>& expected,
|
|
const std::list<SerializedLogChunk>& chunks);
|
|
|
|
class LogEntryIterator {
|
|
public:
|
|
LogEntryIterator(SerializedLogChunk& chunk, int read_offset_)
|
|
: chunk_(chunk), read_offset_(read_offset_) {}
|
|
|
|
LogEntryIterator& operator++() {
|
|
read_offset_ += chunk_.log_entry(read_offset_)->total_len();
|
|
return *this;
|
|
}
|
|
|
|
bool operator!=(const LogEntryIterator& other) const {
|
|
return read_offset_ != other.read_offset_;
|
|
}
|
|
const SerializedLogEntry& operator*() const { return *chunk_.log_entry(read_offset_); }
|
|
|
|
private:
|
|
SerializedLogChunk& chunk_;
|
|
int read_offset_;
|
|
};
|
|
|
|
explicit SerializedLogChunk(size_t size) : contents_(size) {}
|
|
SerializedLogChunk(SerializedLogChunk&& other) noexcept = default;
|
|
~SerializedLogChunk();
|
|
|
|
void FinishWriting();
|
|
void IncReaderRefCount();
|
|
void DecReaderRefCount();
|
|
void AttachReader(SerializedFlushToState* reader);
|
|
void DetachReader(SerializedFlushToState* reader);
|
|
|
|
void NotifyReadersOfPrune(log_id_t log_id) REQUIRES(logd_lock);
|
|
|
|
bool CanLog(size_t len);
|
|
SerializedLogEntry* Log(uint64_t sequence, log_time realtime, uid_t uid, pid_t pid, pid_t tid,
|
|
const char* msg, uint16_t len);
|
|
|
|
// If this buffer has been compressed, we only consider its compressed size when accounting for
|
|
// memory consumption for pruning. This is since the uncompressed log is only by used by
|
|
// readers, and thus not a representation of how much these logs cost to keep in memory.
|
|
size_t PruneSize() const {
|
|
return sizeof(*this) + (compressed_log_.size() ?: contents_.size());
|
|
}
|
|
|
|
const SerializedLogEntry* log_entry(int offset) const {
|
|
CHECK(writer_active_ || reader_ref_count_ > 0);
|
|
return reinterpret_cast<const SerializedLogEntry*>(data() + offset);
|
|
}
|
|
const uint8_t* data() const { return contents_.data(); }
|
|
int write_offset() const { return write_offset_; }
|
|
uint64_t highest_sequence_number() const { return highest_sequence_number_; }
|
|
|
|
LogEntryIterator begin() { return LogEntryIterator(*this, 0); }
|
|
|
|
LogEntryIterator end() { return LogEntryIterator(*this, write_offset_); }
|
|
|
|
// Exposed for testing
|
|
uint32_t reader_ref_count() const { return reader_ref_count_; }
|
|
|
|
private:
|
|
// The decompressed contents of this log buffer. Deallocated when the ref_count reaches 0 and
|
|
// writer_active_ is false.
|
|
SerializedData contents_;
|
|
int write_offset_ = 0;
|
|
uint32_t reader_ref_count_ = 0;
|
|
bool writer_active_ = true;
|
|
uint64_t highest_sequence_number_ = 1;
|
|
SerializedData compressed_log_;
|
|
std::vector<SerializedFlushToState*> readers_;
|
|
};
|