Merge "logd: use the compressed (serialized) log buffer by default" (864a2dbe) · Commits · e / os / android_system_core

logd/logd_test.cpp

+0 −124

Original line number	Diff line number	Diff line
		@@ -832,127 +832,3 @@ TEST(logd, getEventTag_newentry) {
		GTEST_LOG_(INFO) << "This test does nothing.\n";
		#endif
		}

		#ifdef __ANDROID__
		static inline uint32_t get4LE(const uint8_t* src) {
		return src[0] \| (src[1] << 8) \| (src[2] << 16) \| (src[3] << 24);
		}

		static inline uint32_t get4LE(const char* src) {
		return get4LE(reinterpret_cast<const uint8_t*>(src));
		}
		#endif

		void __android_log_btwrite_multiple__helper(int count) {
		#ifdef __ANDROID__
		log_time ts(CLOCK_MONOTONIC);
		usleep(100);
		log_time ts1(CLOCK_MONOTONIC);

		// We fork to create a unique pid for the submitted log messages
		// so that we do not collide with the other _multiple_ tests.

		pid_t pid = fork();

		if (pid == 0) {
		// child
		for (int i = count; i; --i) {
		ASSERT_LT(
		0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
		usleep(100);
		}
		ASSERT_LT(0,
		__android_log_btwrite(0, EVENT_TYPE_LONG, &ts1, sizeof(ts1)));
		usleep(1000000);

		_exit(0);
		}

		siginfo_t info = {};
		ASSERT_EQ(0, TEMP_FAILURE_RETRY(waitid(P_PID, pid, &info, WEXITED)));
		ASSERT_EQ(0, info.si_status);

		struct logger_list* logger_list;
		ASSERT_TRUE(nullptr != (logger_list = android_logger_list_open(LOG_ID_EVENTS,
		ANDROID_LOG_NONBLOCK, 0, pid)));

		int expected_count = (count < 2) ? count : 2;
		int expected_chatty_count = (count <= 2) ? 0 : 1;
		int expected_identical_count = (count < 2) ? 0 : (count - 2);
		static const int expected_expire_count = 0;

		count = 0;
		int second_count = 0;
		int chatty_count = 0;
		int identical_count = 0;
		int expire_count = 0;

		for (;;) {
		log_msg log_msg;
		if (android_logger_list_read(logger_list, &log_msg) <= 0) break;

		if ((log_msg.entry.pid != pid) \|\| (log_msg.entry.len < (4 + 1 + 8)) \|\|
		(log_msg.id() != LOG_ID_EVENTS))
		continue;

		char* eventData = log_msg.msg();
		if (!eventData) continue;

		uint32_t tag = get4LE(eventData);

		if ((eventData[4] == EVENT_TYPE_LONG) &&
		(log_msg.entry.len == (4 + 1 + 8))) {
		if (tag != 0) continue;

		log_time* tx = reinterpret_cast<log_time*>(eventData + 4 + 1);
		if (ts == *tx) {
		++count;
		} else if (ts1 == *tx) {
		++second_count;
		}
		} else if (eventData[4] == EVENT_TYPE_STRING) {
		if (tag != CHATTY_LOG_TAG) continue;
		++chatty_count;
		// int len = get4LE(eventData + 4 + 1);
		log_msg.buf[LOGGER_ENTRY_MAX_LEN] = '\0';
		const char* cp;
		if ((cp = strstr(eventData + 4 + 1 + 4, " identical "))) {
		unsigned val = 0;
		sscanf(cp, " identical %u lines", &val);
		identical_count += val;
		} else if ((cp = strstr(eventData + 4 + 1 + 4, " expire "))) {
		unsigned val = 0;
		sscanf(cp, " expire %u lines", &val);
		expire_count += val;
		}
		}
		}

		android_logger_list_close(logger_list);

		EXPECT_EQ(expected_count, count);
		EXPECT_EQ(1, second_count);
		EXPECT_EQ(expected_chatty_count, chatty_count);
		EXPECT_EQ(expected_identical_count, identical_count);
		EXPECT_EQ(expected_expire_count, expire_count);
		#else
		count = 0;
		GTEST_LOG_(INFO) << "This test does nothing.\n";
		#endif
		}

		TEST(logd, multiple_test_1) {
		__android_log_btwrite_multiple__helper(1);
		}

		TEST(logd, multiple_test_2) {
		__android_log_btwrite_multiple__helper(2);
		}

		TEST(logd, multiple_test_3) {
		__android_log_btwrite_multiple__helper(3);
		}

		TEST(logd, multiple_test_10) {
		__android_log_btwrite_multiple__helper(10);
		}

logd/main.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -258,7 +258,7 @@ int main(int argc, char* argv[]) {
		// Pruning configuration.
		PruneList prune_list;

		std::string buffer_type = GetProperty("logd.buffer_type", "chatty");
		std::string buffer_type = GetProperty("logd.buffer_type", "serialized");

		// Partial (required for chatty) or full logging statistics.
		bool enable_full_log_statistics = __android_logger_property_get_bool(