logd: rename FlushToResult to FilterResult (3e61a136) · Commits · e / os / android_system_core

logd/LogBuffer.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,7 @@

	class LogWriter;		class LogWriter;

	enum class FlushToResult {		enum class FilterResult {
	kSkip,		kSkip,
	kStop,		kStop,
	kWrite,		kWrite,
	@@ -48,7 +48,7 @@ class LogBuffer {
	virtual uint64_t FlushTo(		virtual uint64_t FlushTo(
	LogWriter* writer, uint64_t start,		LogWriter* writer, uint64_t start,
	pid_t* last_tid, // nullable		pid_t* last_tid, // nullable
	const std::function<FlushToResult(const LogBufferElement* element)>& filter) = 0;		const std::function<FilterResult(const LogBufferElement* element)>& filter) = 0;

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

logd/LogReader.cpp

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -172,26 +172,26 @@ bool LogReader::onDataAvailable(SocketClient* cli) {
	bool start_time_set = false;		bool start_time_set = false;
	uint64_t last = sequence;		uint64_t last = sequence;
	auto log_find_start = [pid, logMask, start, &sequence, &start_time_set,		auto log_find_start = [pid, logMask, start, &sequence, &start_time_set,
	&last](const LogBufferElement* element) -> FlushToResult {		&last](const LogBufferElement* element) -> FilterResult {
	if (pid && pid != element->getPid()) {		if (pid && pid != element->getPid()) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}
	if ((logMask & (1 << element->getLogId())) == 0) {		if ((logMask & (1 << element->getLogId())) == 0) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}
	if (start == element->getRealTime()) {		if (start == element->getRealTime()) {
	sequence = element->getSequence();		sequence = element->getSequence();
	start_time_set = true;		start_time_set = true;
	return FlushToResult::kStop;		return FilterResult::kStop;
	} else {		} else {
	if (start < element->getRealTime()) {		if (start < element->getRealTime()) {
	sequence = last;		sequence = last;
	start_time_set = true;		start_time_set = true;
	return FlushToResult::kStop;		return FilterResult::kStop;
	}		}
	last = element->getSequence();		last = element->getSequence();
	}		}
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	};		};

	log_buffer_->FlushTo(socket_log_writer.get(), sequence, nullptr, log_find_start);		log_buffer_->FlushTo(socket_log_writer.get(), sequence, nullptr, log_find_start);

logd/LogReaderThread.cpp

+14 −14

Original line number	Original line	Diff line number	Diff line
	@@ -123,12 +123,12 @@ void LogReaderThread::ThreadFunction() {
	}		}

	// A first pass to count the number of elements		// A first pass to count the number of elements
	FlushToResult LogReaderThread::FilterFirstPass(const LogBufferElement* element) {		FilterResult LogReaderThread::FilterFirstPass(const LogBufferElement* element) {
	auto lock = std::lock_guard{reader_list_->reader_threads_lock()};		auto lock = std::lock_guard{reader_list_->reader_threads_lock()};

	if (leading_dropped_) {		if (leading_dropped_) {
	if (element->getDropped()) {		if (element->getDropped()) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}
	leading_dropped_ = false;		leading_dropped_ = false;
	}		}
	@@ -142,46 +142,46 @@ FlushToResult LogReaderThread::FilterFirstPass(const LogBufferElement* element)
	++count_;		++count_;
	}		}

	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	// A second pass to send the selected elements		// A second pass to send the selected elements
	FlushToResult LogReaderThread::FilterSecondPass(const LogBufferElement* element) {		FilterResult LogReaderThread::FilterSecondPass(const LogBufferElement* element) {
	auto lock = std::lock_guard{reader_list_->reader_threads_lock()};		auto lock = std::lock_guard{reader_list_->reader_threads_lock()};

	start_ = element->getSequence();		start_ = element->getSequence();

	if (skip_ahead_[element->getLogId()]) {		if (skip_ahead_[element->getLogId()]) {
	skip_ahead_[element->getLogId()]--;		skip_ahead_[element->getLogId()]--;
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	if (leading_dropped_) {		if (leading_dropped_) {
	if (element->getDropped()) {		if (element->getDropped()) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}
	leading_dropped_ = false;		leading_dropped_ = false;
	}		}

	// Truncate to close race between first and second pass		// Truncate to close race between first and second pass
	if (non_block_ && tail_ && index_ >= count_) {		if (non_block_ && tail_ && index_ >= count_) {
	return FlushToResult::kStop;		return FilterResult::kStop;
	}		}

	if (!IsWatching(element->getLogId())) {		if (!IsWatching(element->getLogId())) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	if (pid_ && pid_ != element->getPid()) {		if (pid_ && pid_ != element->getPid()) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	if (start_time_ != log_time::EPOCH && element->getRealTime() <= start_time_) {		if (start_time_ != log_time::EPOCH && element->getRealTime() <= start_time_) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	if (release_) {		if (release_) {
	return FlushToResult::kStop;		return FilterResult::kStop;
	}		}

	if (!tail_) {		if (!tail_) {
	@@ -191,7 +191,7 @@ FlushToResult LogReaderThread::FilterSecondPass(const LogBufferElement* element)
	++index_;		++index_;

	if (count_ > tail_ && index_ <= (count_ - tail_)) {		if (count_ > tail_ && index_ <= (count_ - tail_)) {
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	if (!non_block_) {		if (!non_block_) {
	@@ -200,9 +200,9 @@ FlushToResult LogReaderThread::FilterSecondPass(const LogBufferElement* element)

	ok:		ok:
	if (!skip_ahead_[element->getLogId()]) {		if (!skip_ahead_[element->getLogId()]) {
	return FlushToResult::kWrite;		return FilterResult::kWrite;
	}		}
	return FlushToResult::kSkip;		return FilterResult::kSkip;
	}		}

	void LogReaderThread::cleanSkip_Locked(void) {		void LogReaderThread::cleanSkip_Locked(void) {

logd/LogReaderThread.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -63,8 +63,8 @@ class LogReaderThread {
	private:		private:
	void ThreadFunction();		void ThreadFunction();
	// flushTo filter callbacks		// flushTo filter callbacks
	FlushToResult FilterFirstPass(const LogBufferElement* element);		FilterResult FilterFirstPass(const LogBufferElement* element);
	FlushToResult FilterSecondPass(const LogBufferElement* element);		FilterResult FilterSecondPass(const LogBufferElement* element);

	std::condition_variable thread_triggered_condition_;		std::condition_variable thread_triggered_condition_;
	LogBuffer* log_buffer_;		LogBuffer* log_buffer_;

logd/SimpleLogBuffer.cpp

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -112,7 +112,7 @@ void SimpleLogBuffer::LogInternal(LogBufferElement&& elem) {

	uint64_t SimpleLogBuffer::FlushTo(		uint64_t SimpleLogBuffer::FlushTo(
	LogWriter* writer, uint64_t start, pid_t* last_tid,		LogWriter* writer, uint64_t start, pid_t* last_tid,
	const std::function<FlushToResult(const LogBufferElement* element)>& filter) {		const std::function<FilterResult(const LogBufferElement* element)>& filter) {
	auto shared_lock = SharedLock{lock_};		auto shared_lock = SharedLock{lock_};

	std::list<LogBufferElement>::iterator it;		std::list<LogBufferElement>::iterator it;
	@@ -146,11 +146,11 @@ uint64_t SimpleLogBuffer::FlushTo(
	}		}

	if (filter) {		if (filter) {
	FlushToResult ret = filter(&element);		FilterResult ret = filter(&element);
	if (ret == FlushToResult::kSkip) {		if (ret == FilterResult::kSkip) {
	continue;		continue;
	}		}
	if (ret == FlushToResult::kStop) {		if (ret == FilterResult::kStop) {
	break;		break;
	}		}
	}		}