Merge changes I957c519b,Iaf4e389e,I92f8056b am: a1f1775172 (bf6fcb60) · Commits · e / os / android_system_core

logd/ChattyLogBuffer.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -217,12 +217,12 @@ LogBufferElementCollection::iterator ChattyLogBuffer::Erase(LogBufferElementColl
		log_id_for_each(i) {
		for (auto b : mLastWorst[i]) {
		if (bad == b.second) {
		android::prdebug("stale mLastWorst[%d] key=%d mykey=%d\n", i, b.first, key);
		LOG(ERROR) << StringPrintf("stale mLastWorst[%d] key=%d mykey=%d", i, b.first, key);
		}
		}
		for (auto b : mLastWorstPidOfSystem[i]) {
		if (bad == b.second) {
		android::prdebug("stale mLastWorstPidOfSystem[%d] pid=%d\n", i, b.first);
		LOG(ERROR) << StringPrintf("stale mLastWorstPidOfSystem[%d] pid=%d", i, b.first);
		}
		}
		}

logd/CommandListener.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@

		#include <string>

		#include <android-base/logging.h>
		#include <android-base/stringprintf.h>
		#include <cutils/sockets.h>
		#include <log/log_properties.h>
		@@ -298,7 +299,7 @@ int CommandListener::ReinitCmd::runCommand(SocketClient* cli, int /argc/,
		char** /argv/) {
		setname();

		android::prdebug("logd reinit");
		LOG(INFO) << "logd reinit";
		buf()->Init();
		prune()->init(nullptr);

logd/LogBufferTest.cpp

+0 −8

Original line number	Diff line number	Diff line
		@@ -43,14 +43,6 @@ bool __android_logger_valid_buffer_size(unsigned long) {
		}
		#endif

		void android::prdebug(const char* fmt, ...) {
		va_list ap;
		va_start(ap, fmt);
		vfprintf(stderr, fmt, ap);
		fprintf(stderr, "\n");
		va_end(ap);
		}

		char* android::uidToName(uid_t) {
		return nullptr;
		}

logd/LogReader.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@

		#include <chrono>

		#include <android-base/logging.h>
		#include <android-base/stringprintf.h>
		#include <cutils/sockets.h>
		#include <private/android_filesystem_config.h>
		@@ -201,9 +202,9 @@ bool LogReader::onDataAvailable(SocketClient* cli) {
		}
		}

		android::prdebug(
		LOG(INFO) << android::base::StringPrintf(
		"logdr: UID=%d GID=%d PID=%d %c tail=%lu logMask=%x pid=%d "
		"start=%" PRIu64 "ns deadline=%" PRIi64 "ns\n",
		"start=%" PRIu64 "ns deadline=%" PRIi64 "ns",
		cli->getUid(), cli->getGid(), cli->getPid(), nonBlock ? 'n' : 'b', tail, logMask,
		(int)pid, start.nsec(), static_cast<int64_t>(deadline.time_since_epoch().count()));

logd/LogStatistics.cpp

+54 −26

Original line number	Diff line number	Diff line
		@@ -36,6 +36,30 @@ static const uint64_t monthSec = 31 * 24 * hourSec;

		std::atomic<size_t> LogStatistics::SizesTotal;

		static std::string TagNameKey(const LogStatisticsElement& element) {
		if (IsBinary(element.log_id)) {
		uint32_t tag = element.tag;
		if (tag) {
		const char* cp = android::tagToName(tag);
		if (cp) {
		return std::string(cp);
		}
		}
		return android::base::StringPrintf("[%" PRIu32 "]", tag);
		}
		const char* msg = element.msg;
		if (!msg) {
		return "chatty";
		}
		++msg;
		uint16_t len = element.msg_len;
		len = (len <= 1) ? 0 : strnlen(msg, len - 1);
		if (!len) {
		return "<NULL>";
		}
		return std::string(msg, len);
		}

		LogStatistics::LogStatistics(bool enable_statistics) : enable(enable_statistics) {
		log_time now(CLOCK_REALTIME);
		log_id_for_each(id) {
		@@ -308,8 +332,9 @@ template <typename TKey, typename TEntry>
		void LogStatistics::WorstTwoWithThreshold(const LogHashtable<TKey, TEntry>& table, size_t threshold,
		int* worst, size_t* worst_sizes,
		size_t* second_worst_sizes) const {
		std::array<const TKey*, 2> max_keys;
		std::array<const TEntry*, 2> max_entries;
		table.MaxEntries(AID_ROOT, 0, &max_entries);
		table.MaxEntries(AID_ROOT, 0, max_keys, max_entries);
		if (max_entries[0] == nullptr \|\| max_entries[1] == nullptr) {
		return;
		}
		@@ -317,7 +342,7 @@ void LogStatistics::WorstTwoWithThreshold(const LogHashtable<TKey, TEntry>& tabl
		// b/24782000: Allow time horizon to extend roughly tenfold, assume average entry length is
		// 100 characters.
		if (worst_sizes > threshold && worst_sizes > (10 * max_entries[0]->dropped_count())) {
		*worst = max_entries[0]->key();
		worst = max_keys[0];
		*second_worst_sizes = max_entries[1]->getSizes();
		if (*second_worst_sizes < threshold) {
		*second_worst_sizes = threshold;
		@@ -340,13 +365,14 @@ void LogStatistics::WorstTwoTags(size_t threshold, int* worst, size_t* worst_siz
		void LogStatistics::WorstTwoSystemPids(log_id id, size_t worst_uid_sizes, int* worst,
		size_t* second_worst_sizes) const {
		auto lock = std::lock_guard{lock_};
		std::array<const pid_t*, 2> max_keys;
		std::array<const PidEntry*, 2> max_entries;
		pidSystemTable[id].MaxEntries(AID_SYSTEM, 0, &max_entries);
		pidSystemTable[id].MaxEntries(AID_SYSTEM, 0, max_keys, max_entries);
		if (max_entries[0] == nullptr \|\| max_entries[1] == nullptr) {
		return;
		}

		*worst = max_entries[0]->key();
		worst = max_keys[0];
		*second_worst_sizes = worst_uid_sizes - max_entries[0]->getSizes() + max_entries[1]->getSizes();
		}

		@@ -412,11 +438,12 @@ void LogStatistics::FormatTmp(const char* nameTmp, uid_t uid, std::string& name,
		}
		}

		std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUIRES(stat.lock_) {
		std::string name = android::base::StringPrintf("%u", uid_);
		std::string UidEntry::format(const LogStatistics& stat, log_id_t id, uid_t uid) const
		REQUIRES(stat.lock_) {
		std::string name = android::base::StringPrintf("%u", uid);
		std::string size = android::base::StringPrintf("%zu", getSizes());

		stat.FormatTmp(nullptr, uid_, name, size, 6);
		stat.FormatTmp(nullptr, uid, name, size, 6);

		std::string pruned = "";
		if (worstUidEnabledForLogid(id)) {
		@@ -474,19 +501,20 @@ std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUI

		std::string output = formatLine(name, size, pruned);

		if (uid_ != AID_SYSTEM) {
		if (uid != AID_SYSTEM) {
		return output;
		}

		static const size_t maximum_sorted_entries = 32;
		std::array<const PidEntry*, maximum_sorted_entries> sorted;
		stat.pidSystemTable[id].MaxEntries(uid_, 0, &sorted);
		std::array<const pid_t*, maximum_sorted_entries> sorted_pids;
		std::array<const PidEntry*, maximum_sorted_entries> sorted_entries;
		stat.pidSystemTable[id].MaxEntries(uid, 0, sorted_pids, sorted_entries);

		std::string byPid;
		size_t index;
		bool hasDropped = false;
		for (index = 0; index < maximum_sorted_entries; ++index) {
		const PidEntry* entry = sorted[index];
		const PidEntry* entry = sorted_entries[index];
		if (!entry) {
		break;
		}
		@@ -496,7 +524,7 @@ std::string UidEntry::format(const LogStatistics& stat, log_id_t id) const REQUI
		if (entry->dropped_count()) {
		hasDropped = true;
		}
		byPid += entry->format(stat, id);
		byPid += entry->format(stat, id, *sorted_pids[index]);
		}
		if (index > 1) { // print this only if interesting
		std::string ditto("\" ");
		@@ -515,9 +543,9 @@ std::string PidEntry::formatHeader(const std::string& name,
		std::string("BYTES"), std::string("NUM"));
		}

		std::string PidEntry::format(const LogStatistics& stat, log_id_t /* id */) const
		std::string PidEntry::format(const LogStatistics& stat, log_id_t, pid_t pid) const
		REQUIRES(stat.lock_) {
		std::string name = android::base::StringPrintf("%5u/%u", pid_, uid_);
		std::string name = android::base::StringPrintf("%5u/%u", pid, uid_);
		std::string size = android::base::StringPrintf("%zu", getSizes());

		stat.FormatTmp(name_, uid_, name, size, 12);
		@@ -538,9 +566,9 @@ std::string TidEntry::formatHeader(const std::string& name,
		std::string("NUM"));
		}

		std::string TidEntry::format(const LogStatistics& stat, log_id_t /* id */) const
		std::string TidEntry::format(const LogStatistics& stat, log_id_t, pid_t tid) const
		REQUIRES(stat.lock_) {
		std::string name = android::base::StringPrintf("%5u/%u", tid(), uid_);
		std::string name = android::base::StringPrintf("%5u/%u", tid, uid_);
		std::string size = android::base::StringPrintf("%zu", getSizes());

		stat.FormatTmp(name_, uid_, name, size, 12);
		@@ -562,8 +590,7 @@ std::string TagEntry::formatHeader(const std::string& name, log_id_t id) const {
		std::string("BYTES"), std::string(isprune ? "NUM" : ""));
		}

		std::string TagEntry::format(const LogStatistics& /* stat */,
		log_id_t /* id */) const {
		std::string TagEntry::format(const LogStatistics&, log_id_t, uint32_t) const {
		std::string name;
		if (uid_ == (uid_t)-1) {
		name = android::base::StringPrintf("%7u", key());
		@@ -594,8 +621,8 @@ std::string TagNameEntry::formatHeader(const std::string& name,
		std::string("BYTES"), std::string(""));
		}

		std::string TagNameEntry::format(const LogStatistics& /* stat */,
		log_id_t /* id */) const {
		std::string TagNameEntry::format(const LogStatistics&, log_id_t,
		const std::string& key_name) const {
		std::string name;
		std::string pidstr;
		if (pid_ != (pid_t)-1) {
		@@ -616,7 +643,7 @@ std::string TagNameEntry::format(const LogStatistics& /* stat */,

		std::string size = android::base::StringPrintf("%zu", getSizes());

		const char* nameTmp = this->name();
		const char* nameTmp = key_name.data();
		if (nameTmp) {
		size_t lenSpace = std::max(16 - name.length(), (size_t)1);
		size_t len = EntryBase::TOTAL_LEN - EntryBase::PRUNED_LEN - size.length() - name.length() -
		@@ -684,15 +711,16 @@ std::string LogStatistics::FormatTable(const LogHashtable<TKey, TEntry>& table,
		REQUIRES(lock_) {
		static const size_t maximum_sorted_entries = 32;
		std::string output;
		std::array<const TEntry*, maximum_sorted_entries> sorted;
		table.MaxEntries(uid, pid, &sorted);
		std::array<const TKey*, maximum_sorted_entries> sorted_keys;
		std::array<const TEntry*, maximum_sorted_entries> sorted_entries;
		table.MaxEntries(uid, pid, sorted_keys, sorted_entries);
		bool header_printed = false;
		for (size_t index = 0; index < maximum_sorted_entries; ++index) {
		const TEntry* entry = sorted[index];
		const TEntry* entry = sorted_entries[index];
		if (!entry) {
		break;
		}
		if (entry->getSizes() <= (sorted[0]->getSizes() / 100)) {
		if (entry->getSizes() <= (sorted_entries[0]->getSizes() / 100)) {
		break;
		}
		if (!header_printed) {
		@@ -700,7 +728,7 @@ std::string LogStatistics::FormatTable(const LogHashtable<TKey, TEntry>& table,
		output += entry->formatHeader(name, id);
		header_printed = true;
		}
		output += entry->format(*this, id);
		output += entry->format(this, id, sorted_keys[index]);
		}
		return output;
		}