Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b44c89ad authored Dec 24, 2022 by Hui Peng

Improve Implemetation of TRACE APIs

The implementation of TRACE APIs (BTIF_TRACE_ERROR etc)
calls LogMsg, which in turn uses LOG_XXX macros to emit logs.
The source location contained in the emitted
logs all point to the place in LogMsg where LOG_XXX macros are
called, instead of the TRACE statements.

This patch changes the signature of LogMsg to take the source
location (file, line num, func name) of the TRACE statements
and dump it TRACE statements via LogMsg.

To avoid logging duplicated source location emitted by LOG_XXX APIs, a series of LOG_XXX_INT macros are introduced, which do not include
source location , and LOG_XXX APIs are implemented based in LOG_XXX_INT
by adding the source location back.

Bug: 264946508
Test: mma package/modules/Bluetooth
Change-Id: I8d0816af48d1c3658421fc89620b60566618c296

parent cb29a568

system/gd/os/log.h

+73 −40

Original line number	Original line	Diff line number	Diff line
	@@ -33,19 +33,19 @@ static_assert(LOG_TAG != nullptr, "LOG_TAG should never be NULL");

	#if defined(FUZZ_TARGET)		#if defined(FUZZ_TARGET)

	#define LOG_VERBOSE(...)		#define LOG_VERBOSE_INT(...)
	#define LOG_DEBUG(...)		#define LOG_DEBUG_INT(...)
	#define LOG_INFO(...)		#define LOG_INFO_INT(...)
	#define LOG_WARN(...)		#define LOG_WARN_INT(...)

	#define LOG_ERROR(...) do { \		#define LOG_ERROR_INT(...) do { \
	fprintf(stderr, __VA_ARGS__); \		fprintf(stderr, __VA_ARGS__); \
	} while (false)		} while (false)

	// for fuzz targets, we just		// for fuzz targets, we just
	// need to abort in this statement		// need to abort in this statement
	// to catch the bug		// to catch the bug
	#define LOG_ALWAYS_FATAL(...) do { \		#define LOG_ALWAYS_FATAL_INT(...) do { \
	fprintf(stderr, __VA_ARGS__); \		fprintf(stderr, __VA_ARGS__); \
	abort(); \		abort(); \
	} while (false)		} while (false)
	@@ -61,40 +61,44 @@ static_assert(LOG_TAG != nullptr, "LOG_TAG should never be NULL");

	#include "common/init_flags.h"		#include "common/init_flags.h"

	#define LOG_VERBOSE(fmt, args...) \		#define LOG_VERBOSE_INT(fmt, args...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \
	ALOGV("%s:%d %s: " fmt, __FILE__, __LINE__, __func__, ##args); \		ALOGV(fmt, ##args); \
	} \		} \
	} while (false)		} while (false)

	#define LOG_DEBUG(fmt, args...) \		#define LOG_DEBUG_INT(fmt, args...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \
	ALOGD("%s:%d %s: " fmt, __FILE__, __LINE__, __func__, ##args); \		ALOGD(fmt, ##args); \
	} \		} \
	} while (false)		} while (false)
	#endif /* __has_include("src/init_flags.rs.h") */		#endif /* __has_include("src/init_flags.rs.h") */

	#define LOG_INFO(fmt, args...) ALOGI("%s:%d %s: " fmt, __FILE__, __LINE__, __func__, ##args)		#define LOG_INFO_INT(fmt, args...) ALOGI(fmt, ##args)
	#define LOG_WARN(fmt, args...) ALOGW("%s:%d %s: " fmt, __FILE__, __LINE__, __func__, ##args)		#define LOG_WARN_INT(fmt, args...) ALOGW(fmt, ##args)
	#define LOG_ERROR(fmt, args...) ALOGE("%s:%d %s: " fmt, __FILE__, __LINE__, __func__, ##args)		#define LOG_ERROR_INT(fmt, args...) ALOGE(fmt, ##args)
			#define LOG_ALWAYS_FATAL_INT(fmt, args...) do { \
			ALOGE(fmt, ##args); \
			abort(); \
			} while (false)

	#elif defined (ANDROID_EMULATOR) /* end of defined(__ANDROID__) */		#elif defined (ANDROID_EMULATOR) /* end of defined(__ANDROID__) */
	// Log using android emulator logging mechanism		// Log using android emulator logging mechanism
	#include "android/utils/debug.h"		#include "android/utils/debug.h"

	#define LOGWRAPPER(fmt, args...) VERBOSE_INFO(bluetooth, "bluetooth: %s:%d - %s: " fmt, \		#define LOGWRAPPER(fmt, args...) VERBOSE_INFO(bluetooth, "bluetooth: " fmt, \
	__FILE__, __LINE__, __func__, ##args)		##args)

	#define LOG_VEBOSE(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_VEBOSE_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_DEBUG(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_DEBUG_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_INFO(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_INFO_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_WARN(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_WARN_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_ERROR(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_ERROR_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_ALWAYS_FATAL(fmt, args...) \		#define LOG_ALWAYS_FATAL_INT(fmt, args...) \
	do { \		do { \
	fprintf(stderr, "%s:%d - %s: " fmt "\n", __FILE__, __LINE__, __func__, ##args); \		fprintf(stderr, fmt "\n", ##args); \
	abort(); \		abort(); \
	} while (false)		} while (false)
	#elif defined(TARGET_FLOSS) /* end of defined (ANDROID_EMULATOR) */		#elif defined(TARGET_FLOSS) /* end of defined (ANDROID_EMULATOR) */
	@@ -103,25 +107,25 @@ static_assert(LOG_TAG != nullptr, "LOG_TAG should never be NULL");

	// Prefix the log with tag, file, line and function		// Prefix the log with tag, file, line and function
	#define LOGWRAPPER(tag, fmt, args...) \		#define LOGWRAPPER(tag, fmt, args...) \
	write_syslog(tag, "%s:%s:%d - %s: " fmt, LOG_TAG, __FILE__, __LINE__, __func__, ##args)		write_syslog(tag, "%s: " fmt, LOG_TAG, ##args)

	#define LOG_VERBOSE(...) \		#define LOG_VERBOSE_INT(...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \
	LOGWRAPPER(LOG_TAG_VERBOSE, __VA_ARGS__); \		LOGWRAPPER(LOG_TAG_VERBOSE, __VA_ARGS__); \
	} \		} \
	} while (false)		} while (false)
	#define LOG_DEBUG(...) \		#define LOG_DEBUG_INT(...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \
	LOGWRAPPER(LOG_TAG_DEBUG, __VA_ARGS__); \		LOGWRAPPER(LOG_TAG_DEBUG, __VA_ARGS__); \
	} \		} \
	} while (false)		} while (false)
	#define LOG_INFO(...) LOGWRAPPER(LOG_TAG_INFO, __VA_ARGS__)		#define LOG_INFO_INT(...) LOGWRAPPER(LOG_TAG_INFO, __VA_ARGS__)
	#define LOG_WARN(...) LOGWRAPPER(LOG_TAG_WARN, __VA_ARGS__)		#define LOG_WARN_INT(...) LOGWRAPPER(LOG_TAG_WARN, __VA_ARGS__)
	#define LOG_ERROR(...) LOGWRAPPER(LOG_TAG_ERROR, __VA_ARGS__)		#define LOG_ERROR_INT(...) LOGWRAPPER(LOG_TAG_ERROR, __VA_ARGS__)

	#define LOG_ALWAYS_FATAL(...) \		#define LOG_ALWAYS_FATAL_INT(...) \
	do { \		do { \
	LOGWRAPPER(LOG_TAG_FATAL, __VA_ARGS__); \		LOGWRAPPER(LOG_TAG_FATAL, __VA_ARGS__); \
	abort(); \		abort(); \
	@@ -162,24 +166,24 @@ static_assert(LOG_TAG != nullptr, "LOG_TAG should never be NULL");
	##args); \		##args); \
	} while (false)		} while (false)

	#define LOG_VERBOSE(fmt, args...) \		#define LOG_VERBOSE_INT(fmt, args...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_VERBOSE) { \
	LOGWRAPPER(fmt, ##args); \		LOGWRAPPER(fmt, ##args); \
	} \		} \
	} while (false)		} while (false)
	#define LOG_DEBUG(fmt, args...) \		#define LOG_DEBUG_INT(fmt, args...) \
	do { \		do { \
	if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \		if (bluetooth::common::InitFlags::GetLogLevelForTag(LOG_TAG) >= LOG_TAG_DEBUG) { \
	LOGWRAPPER(fmt, ##args); \		LOGWRAPPER(fmt, ##args); \
	} \		} \
	} while (false)		} while (false)
	#define LOG_INFO(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_INFO_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_WARN(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_WARN_INT(...) LOGWRAPPER(__VA_ARGS__)
	#define LOG_ERROR(...) LOGWRAPPER(__VA_ARGS__)		#define LOG_ERROR_INT(...) LOGWRAPPER(__VA_ARGS__)

	#ifndef LOG_ALWAYS_FATAL		#ifndef LOG_ALWAYS_FATAL
	#define LOG_ALWAYS_FATAL(...) \		#define LOG_ALWAYS_FATAL_INT(...) \
	do { \		do { \
	LOGWRAPPER(__VA_ARGS__); \		LOGWRAPPER(__VA_ARGS__); \
	abort(); \		abort(); \
	@@ -190,6 +194,35 @@ static_assert(LOG_TAG != nullptr, "LOG_TAG should never be NULL");

	#endif /* defined(FUZZ_TARGET) */		#endif /* defined(FUZZ_TARGET) */

			#define _LOG_SRC_FMT_STR "%s:%d - %s: "

			// ---------------------------------------------------------
			// All MACROs defined above are internal and should not be
			// used directly (use LOG_XXX defined below instead).
			// the output of LOG_XXX_INT does not contain the source
			// location of the log emitting statement, so far they are only used by
			// LogMsg, where the source locations is passed in.

			#define LOG_VERBOSE(fmt, args...) \
			LOG_VERBOSE_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)

			#define LOG_DEBUG(fmt, args...) \
			LOG_DEBUG_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)

			#define LOG_INFO(fmt, args...) \
			LOG_INFO_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)

			#define LOG_WARN(fmt, args...) \
			LOG_WARN_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)

			#define LOG_ERROR(fmt, args...) \
			LOG_ERROR_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)

			#ifndef LOG_ALWAYS_FATAL
			#define LOG_ALWAYS_FATAL(fmt, args...) \
			LOG_ALWAYS_FATAL_INT(_LOG_SRC_FMT_STR fmt, __FILE__, __LINE__, __func__, ##args)
			#endif

	#define ASSERT(condition) \		#define ASSERT(condition) \
	do { \		do { \
	if (!(condition)) { \		if (!(condition)) { \

system/internal_include/bt_trace.h

+43 −39

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,12 @@

	#include <stdint.h>		#include <stdint.h>

			// move this function outof extern "C" block
			// as it is a C++ function.
			extern void LogMsg(uint32_t trace_set_mask,
			const char filename, uint32_t linenum, const char func,
			const char* fmt_str, ...);

	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	@@ -245,7 +251,7 @@ static const char BTE_LOGMSG_MODULE[] = "bte_logmsg_module";
	#endif		#endif

	#define BT_TRACE(l, t, ...) \		#define BT_TRACE(l, t, ...) \
	LogMsg((TRACE_CTRL_GENERAL \| (l) \| TRACE_ORG_STACK \| (t)), ##__VA_ARGS__)		LogMsg((TRACE_CTRL_GENERAL \| (l) \| TRACE_ORG_STACK \| (t)), __FILE__, __LINE__, __func__, ##__VA_ARGS__)

	/* Define tracing for the HCI unit */		/* Define tracing for the HCI unit */
	#define HCI_TRACE_ERROR(...) \		#define HCI_TRACE_ERROR(...) \
	@@ -636,42 +642,42 @@ extern uint8_t btif_trace_level;
	#define BTIF_TRACE_ERROR(...) \		#define BTIF_TRACE_ERROR(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_ERROR) \		if (btif_trace_level >= BT_TRACE_LEVEL_ERROR) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_ERROR, \		TRACE_TYPE_ERROR, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define BTIF_TRACE_WARNING(...) \		#define BTIF_TRACE_WARNING(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_WARNING) \		if (btif_trace_level >= BT_TRACE_LEVEL_WARNING) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_WARNING, \		TRACE_TYPE_WARNING, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define BTIF_TRACE_API(...) \		#define BTIF_TRACE_API(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_API) \		if (btif_trace_level >= BT_TRACE_LEVEL_API) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_API, \		TRACE_TYPE_API, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define BTIF_TRACE_EVENT(...) \		#define BTIF_TRACE_EVENT(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_EVENT) \		if (btif_trace_level >= BT_TRACE_LEVEL_EVENT) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_EVENT, \		TRACE_TYPE_EVENT, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define BTIF_TRACE_DEBUG(...) \		#define BTIF_TRACE_DEBUG(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_DEBUG) \		if (btif_trace_level >= BT_TRACE_LEVEL_DEBUG) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_DEBUG, \		TRACE_TYPE_DEBUG, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define BTIF_TRACE_VERBOSE(...) \		#define BTIF_TRACE_VERBOSE(...) \
	{ \		{ \
	if (btif_trace_level >= BT_TRACE_LEVEL_VERBOSE) \		if (btif_trace_level >= BT_TRACE_LEVEL_VERBOSE) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_DEBUG, \		TRACE_TYPE_DEBUG, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	@@ -680,42 +686,42 @@ extern uint8_t btif_trace_level;
	#define APPL_TRACE_ERROR(...) \		#define APPL_TRACE_ERROR(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_ERROR) \		if (appl_trace_level >= BT_TRACE_LEVEL_ERROR) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_ERROR, \		TRACE_TYPE_ERROR, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define APPL_TRACE_WARNING(...) \		#define APPL_TRACE_WARNING(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_WARNING) \		if (appl_trace_level >= BT_TRACE_LEVEL_WARNING) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_WARNING, \		TRACE_TYPE_WARNING, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define APPL_TRACE_API(...) \		#define APPL_TRACE_API(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_API) \		if (appl_trace_level >= BT_TRACE_LEVEL_API) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_API, \		TRACE_TYPE_API, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define APPL_TRACE_EVENT(...) \		#define APPL_TRACE_EVENT(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_EVENT) \		if (appl_trace_level >= BT_TRACE_LEVEL_EVENT) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_EVENT, \		TRACE_TYPE_EVENT, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define APPL_TRACE_DEBUG(...) \		#define APPL_TRACE_DEBUG(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_DEBUG) \		if (appl_trace_level >= BT_TRACE_LEVEL_DEBUG) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_DEBUG, \		TRACE_TYPE_DEBUG, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	#define APPL_TRACE_VERBOSE(...) \		#define APPL_TRACE_VERBOSE(...) \
	{ \		{ \
	if (appl_trace_level >= BT_TRACE_LEVEL_VERBOSE) \		if (appl_trace_level >= BT_TRACE_LEVEL_VERBOSE) \
	LogMsg(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL \| \		BT_TRACE(TRACE_CTRL_GENERAL \| TRACE_LAYER_NONE \| TRACE_ORG_APPL,\
	TRACE_TYPE_DEBUG, \		TRACE_TYPE_DEBUG, \
	##__VA_ARGS__); \		##__VA_ARGS__); \
	}		}
	@@ -735,8 +741,6 @@ typedef struct {
	* declaration in all the files using APPL_TRACExxx macros */		* declaration in all the files using APPL_TRACExxx macros */
	extern uint8_t appl_trace_level;		extern uint8_t appl_trace_level;

	void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...);

	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif

system/main/bte_logmsg.cc

+11 −7

Original line number	Original line	Diff line number	Diff line
	@@ -87,7 +87,9 @@ static const char* const bt_layer_tags[] = {
	"bt_nfa",		"bt_nfa",
	};		};

	void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...) {		void LogMsg(uint32_t trace_set_mask,
			const char* filename, uint32_t linenum, const char* func,
			const char* fmt_str, ...) {
	char buffer[BTE_LOG_BUF_SIZE];		char buffer[BTE_LOG_BUF_SIZE];
	int trace_layer = TRACE_GET_LAYER(trace_set_mask);		int trace_layer = TRACE_GET_LAYER(trace_set_mask);
	if (trace_layer >= TRACE_LAYER_MAX_NUM) trace_layer = 0;		if (trace_layer >= TRACE_LAYER_MAX_NUM) trace_layer = 0;
	@@ -102,24 +104,26 @@ void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...) {

	switch (TRACE_GET_TYPE(trace_set_mask)) {		switch (TRACE_GET_TYPE(trace_set_mask)) {
	case TRACE_TYPE_ERROR:		case TRACE_TYPE_ERROR:
	LOG_ERROR("%s", buffer);		LOG_ERROR_INT(_LOG_SRC_FMT_STR "%s", filename, linenum, func, buffer);
	break;		break;
	case TRACE_TYPE_WARNING:		case TRACE_TYPE_WARNING:
	LOG_WARN("%s", buffer);		LOG_WARN_INT(_LOG_SRC_FMT_STR "%s", filename, linenum, func, buffer);
	break;		break;
	case TRACE_TYPE_API:		case TRACE_TYPE_API:
	case TRACE_TYPE_EVENT:		case TRACE_TYPE_EVENT:
	LOG_INFO("%s", buffer);		LOG_INFO_INT(_LOG_SRC_FMT_STR "%s", filename, linenum, func, buffer);
	break;		break;
	case TRACE_TYPE_DEBUG:		case TRACE_TYPE_DEBUG:
	LOG_INFO("%s", buffer);		LOG_DEBUG_INT(_LOG_SRC_FMT_STR "%s", filename, linenum, func, buffer);
	break;		break;
	case TRACE_TYPE_INFO:		case TRACE_TYPE_INFO:
	LOG_INFO("%s", buffer);		LOG_INFO_INT(_LOG_SRC_FMT_STR "%s", filename, linenum, func, buffer);
	break;		break;
	default:		default:
	/* we should never get this */		/* we should never get this */
	LOG_ERROR("!BAD TRACE TYPE! %s", buffer);		LOG_ERROR_INT("!BAD TRACE TYPE! " _LOG_SRC_FMT_STR "%s", filename,
			linenum, func, buffer);

	CHECK(TRACE_GET_TYPE(trace_set_mask) == TRACE_TYPE_ERROR);		CHECK(TRACE_GET_TYPE(trace_set_mask) == TRACE_TYPE_ERROR);
	break;		break;
	}		}

system/test/common/log_msg.cc

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -33,7 +33,9 @@ std::function<void(uint32_t, const char*)> bluetooth::testing::common::log_msg =
	[]([[maybe_unused]] uint32_t trace_set_mask,		[]([[maybe_unused]] uint32_t trace_set_mask,
	[[maybe_unused]] const char* buffer) {};		[[maybe_unused]] const char* buffer) {};

	extern "C" void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...) {		void LogMsg(uint32_t trace_set_mask,
			const char* filename, uint32_t linenum, const char* func,
			const char* fmt_str, ...) {
	char buffer[kTestBufferLogSize];		char buffer[kTestBufferLogSize];

	va_list ap;		va_list ap;

system/test/common/log_msg_test.cc

+9 −6

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,9 @@ namespace {
	uint32_t kDefaultTraceSetMask = 0x5a5a5a5a;		uint32_t kDefaultTraceSetMask = 0x5a5a5a5a;
	}		}

			#define _LogMsg(trace_set_mask, msg) \
			LogMsg(trace_set_mask, __FILE__, __LINE__, __func__, msg)

	class CommonLogMsgTest : public ::testing::Test {		class CommonLogMsgTest : public ::testing::Test {
	protected:		protected:
	void SetUp() override {}		void SetUp() override {}
	@@ -58,35 +61,35 @@ class CommonLogMsgOutputTest : public CommonLogMsgTest {
	};		};

	TEST_F(CommonLogMsgTest, default_no_output) {		TEST_F(CommonLogMsgTest, default_no_output) {
	LogMsg(kDefaultTraceSetMask, "This is a test");		_LogMsg(kDefaultTraceSetMask, "This is a test");
	}		}

	TEST_F(CommonLogMsgOutputTest, simple_with_output) {		TEST_F(CommonLogMsgOutputTest, simple_with_output) {
	LogMsg(kDefaultTraceSetMask, "This will be printed\n");		_LogMsg(kDefaultTraceSetMask, "This will be printed\n");
	ASSERT_EQ(kDefaultTraceSetMask, last_.mask);		ASSERT_EQ(kDefaultTraceSetMask, last_.mask);
	ASSERT_EQ(strlen("This will be printed\n"), last_.data_len);		ASSERT_EQ(strlen("This will be printed\n"), last_.data_len);
	}		}

	TEST_F(CommonLogMsgOutputTest, simple_with_no_output) {		TEST_F(CommonLogMsgOutputTest, simple_with_no_output) {
	LogMsg(0U, "This will not be printed\n");		_LogMsg(0U, "This will not be printed\n");
	ASSERT_EQ(0U, last_.mask);		ASSERT_EQ(0U, last_.mask);
	ASSERT_EQ(0UL, last_.data_len);		ASSERT_EQ(0UL, last_.data_len);
	}		}

	TEST_F(CommonLogMsgOutputTest, max_string) {		TEST_F(CommonLogMsgOutputTest, max_string) {
	auto long_string = std::string(max_buffer_size_ - sizeof('\0'), 'x');		auto long_string = std::string(max_buffer_size_ - sizeof('\0'), 'x');
	LogMsg(kDefaultTraceSetMask, long_string.c_str());		_LogMsg(kDefaultTraceSetMask, long_string.c_str());
	ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);		ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);
	}		}

	TEST_F(CommonLogMsgOutputTest, max_string_plus_string_terminator) {		TEST_F(CommonLogMsgOutputTest, max_string_plus_string_terminator) {
	auto long_string = std::string(max_buffer_size_, 'x');		auto long_string = std::string(max_buffer_size_, 'x');
	LogMsg(kDefaultTraceSetMask, long_string.c_str());		_LogMsg(kDefaultTraceSetMask, long_string.c_str());
	ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);		ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);
	}		}

	TEST_F(CommonLogMsgOutputTest, too_large_string) {		TEST_F(CommonLogMsgOutputTest, too_large_string) {
	auto long_string = std::string(4096UL, 'x');		auto long_string = std::string(4096UL, 'x');
	LogMsg(kDefaultTraceSetMask, long_string.c_str());		_LogMsg(kDefaultTraceSetMask, long_string.c_str());
	ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);		ASSERT_EQ(max_buffer_size_ - sizeof('\0'), last_.data_len);
	}		}