Merge "Move tombstone_proto_to_text out of libdebuggerd." into main (73ade161) · Commits · e / os / android_system_core

debuggerd/Android.bp

+37 −2

Original line number	Diff line number	Diff line
		@@ -186,6 +186,41 @@ cc_library {
		export_include_dirs: ["include"],
		}

		cc_library {
		name: "libdebuggerd_tombstone_proto_to_text",
		defaults: ["debuggerd_defaults"],
		ramdisk_available: true,
		recovery_available: true,
		vendor_ramdisk_available: true,

		local_include_dirs: ["libdebuggerd/include"],
		export_include_dirs: ["libdebuggerd/include"],

		srcs: [
		"libdebuggerd/tombstone_proto_to_text.cpp",
		],

		header_libs: [
		"bionic_libc_platform_headers",
		],

		static_libs: [
		"libbase",
		"liblog_for_runtime_apex",
		"libunwindstack",
		],

		whole_static_libs: [
		"libtombstone_proto",
		"libprotobuf-cpp-lite",
		],

		apex_available: [
		"//apex_available:platform",
		"com.android.runtime",
		],
		}

		cc_library_static {
		name: "libdebuggerd",
		defaults: ["debuggerd_defaults"],
		@@ -199,7 +234,6 @@ cc_library_static {
		"libdebuggerd/open_files_list.cpp",
		"libdebuggerd/tombstone.cpp",
		"libdebuggerd/tombstone_proto.cpp",
		"libdebuggerd/tombstone_proto_to_text.cpp",
		"libdebuggerd/utility.cpp",
		],

		@@ -225,6 +259,7 @@ cc_library_static {
		],

		whole_static_libs: [
		"libdebuggerd_tombstone_proto_to_text",
		"libasync_safe",
		"gwp_asan_crash_handler",
		"libtombstone_proto",
		@@ -309,7 +344,7 @@ cc_test {
		"libdebuggerd/test/elf_fake.cpp",
		"libdebuggerd/test/log_fake.cpp",
		"libdebuggerd/test/open_files_list_test.cpp",
		"libdebuggerd/test/utility_test.cpp",
		"libdebuggerd/test/tombstone_proto_to_text_test.cpp",
		],

		target: {

debuggerd/libdebuggerd/include/libdebuggerd/utility.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -91,8 +91,6 @@ bool signal_has_si_addr(const siginfo_t*);
		void get_signal_sender(char* buf, size_t n, const siginfo_t*);
		const char* get_signame(const siginfo_t*);
		const char* get_sigcode(const siginfo_t*);
		std::string describe_tagged_addr_ctrl(long ctrl);
		std::string describe_pac_enabled_keys(long keys);

		// Number of bytes per MTE granule.
		constexpr size_t kTagGranuleSize = 16;

debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp

0 → 100644

+120 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.
		*/

		#include <gtest/gtest.h>
		#include <sys/prctl.h>

		#include <string>

		#include <android-base/test_utils.h>

		#include "libdebuggerd/tombstone.h"
		#include "tombstone.pb.h"

		using CallbackType = std::function<void(const std::string& line, bool should_log)>;

		class TombstoneProtoToTextTest : public ::testing::Test {
		public:
		void SetUp() {
		tombstone_.reset(new Tombstone);

		tombstone_->set_arch(Architecture::ARM64);
		tombstone_->set_build_fingerprint("Test fingerprint");
		tombstone_->set_timestamp("1970-01-01 00:00:00");
		tombstone_->set_pid(100);
		tombstone_->set_tid(100);
		tombstone_->set_uid(0);
		tombstone_->set_selinux_label("none");

		Signal signal;
		signal.set_number(SIGSEGV);
		signal.set_name("SIGSEGV");
		signal.set_code(0);
		signal.set_code_name("none");

		*tombstone_->mutable_signal_info() = signal;

		Thread thread;
		thread.set_id(100);
		thread.set_name("main");
		thread.set_tagged_addr_ctrl(0);
		thread.set_pac_enabled_keys(0);

		auto& threads = *tombstone_->mutable_threads();
		threads[100] = thread;
		main_thread_ = &threads[100];
		}

		void ProtoToString() {
		text_ = "";
		EXPECT_TRUE(
		tombstone_proto_to_text(*tombstone_, [this](const std::string& line, bool should_log) {
		if (should_log) {
		text_ += "LOG ";
		}
		text_ += line + '\n';
		}));
		}

		Thread* main_thread_;
		std::string text_;
		std::unique_ptr<Tombstone> tombstone_;
		};

		TEST_F(TombstoneProtoToTextTest, tagged_addr_ctrl) {
		main_thread_->set_tagged_addr_ctrl(0);
		ProtoToString();
		EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000000\\n");

		main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE);
		ProtoToString();
		EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000001 \\(PR_TAGGED_ADDR_ENABLE\\)\\n");

		main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE \| PR_MTE_TCF_SYNC \|
		(0xfffe << PR_MTE_TAG_SHIFT));
		ProtoToString();
		EXPECT_MATCH(text_,
		"LOG tagged_addr_ctrl: 000000000007fff3 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "
		"mask 0xfffe\\)\\n");

		main_thread_->set_tagged_addr_ctrl(0xf0000000 \| PR_TAGGED_ADDR_ENABLE \| PR_MTE_TCF_SYNC \|
		PR_MTE_TCF_ASYNC \| (0xfffe << PR_MTE_TAG_SHIFT));
		ProtoToString();
		EXPECT_MATCH(text_,
		"LOG tagged_addr_ctrl: 00000000f007fff7 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "
		"PR_MTE_TCF_ASYNC, mask 0xfffe, unknown 0xf0000000\\)\\n");
		}

		TEST_F(TombstoneProtoToTextTest, pac_enabled_keys) {
		main_thread_->set_pac_enabled_keys(0);
		ProtoToString();
		EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000000\\n");

		main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY);
		ProtoToString();
		EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000001 \\(PR_PAC_APIAKEY\\)\\n");

		main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY \| PR_PAC_APDBKEY);
		ProtoToString();
		EXPECT_MATCH(text_,
		"LOG pac_enabled_keys: 0000000000000009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY\\)\\n");

		main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY \| PR_PAC_APDBKEY \| 0x1000);
		ProtoToString();
		EXPECT_MATCH(text_,
		"LOG pac_enabled_keys: 0000000000001009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown "
		"0x1000\\)\\n");
		}

debuggerd/libdebuggerd/test/utility_test.cpp

deleted100644 → 0

+0 −42

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.
		*/

		#include <gtest/gtest.h>
		#include <sys/prctl.h>

		#include "libdebuggerd/utility.h"

		TEST(UtilityTest, describe_tagged_addr_ctrl) {
		EXPECT_EQ("", describe_tagged_addr_ctrl(0));
		EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE)", describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE));
		EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, mask 0xfffe)",
		describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE \| PR_MTE_TCF_SYNC \|
		(0xfffe << PR_MTE_TAG_SHIFT)));
		EXPECT_EQ(
		" (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, PR_MTE_TCF_ASYNC, mask 0xfffe, unknown "
		"0xf0000000)",
		describe_tagged_addr_ctrl(0xf0000000 \| PR_TAGGED_ADDR_ENABLE \| PR_MTE_TCF_SYNC \|
		PR_MTE_TCF_ASYNC \| (0xfffe << PR_MTE_TAG_SHIFT)));
		}

		TEST(UtilityTest, describe_pac_enabled_keys) {
		EXPECT_EQ("", describe_pac_enabled_keys(0));
		EXPECT_EQ(" (PR_PAC_APIAKEY)", describe_pac_enabled_keys(PR_PAC_APIAKEY));
		EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY)",
		describe_pac_enabled_keys(PR_PAC_APIAKEY \| PR_PAC_APDBKEY));
		EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown 0x1000)",
		describe_pac_enabled_keys(PR_PAC_APIAKEY \| PR_PAC_APDBKEY \| 0x1000));
		}

debuggerd/libdebuggerd/tombstone_proto_to_text.cpp

+37 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include <android-base/strings.h>
		#include <android-base/unique_fd.h>
		#include <bionic/macros.h>
		#include <sys/prctl.h>

		#include "tombstone.pb.h"

		@@ -40,6 +41,42 @@ using android::base::StringPrintf;
		#define CBS(...) CB(false, __VA_ARGS__)
		using CallbackType = std::function<void(const std::string& line, bool should_log)>;

		#define DESCRIBE_FLAG(flag) \
		if (value & flag) { \
		desc += ", "; \
		desc += #flag; \
		value &= ~flag; \
		}

		static std::string describe_end(long value, std::string& desc) {
		if (value) {
		desc += StringPrintf(", unknown 0x%lx", value);
		}
		return desc.empty() ? "" : " (" + desc.substr(2) + ")";
		}

		static std::string describe_tagged_addr_ctrl(long value) {
		std::string desc;
		DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);
		DESCRIBE_FLAG(PR_MTE_TCF_SYNC);
		DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);
		if (value & PR_MTE_TAG_MASK) {
		desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);
		value &= ~PR_MTE_TAG_MASK;
		}
		return describe_end(value, desc);
		}

		static std::string describe_pac_enabled_keys(long value) {
		std::string desc;
		DESCRIBE_FLAG(PR_PAC_APIAKEY);
		DESCRIBE_FLAG(PR_PAC_APIBKEY);
		DESCRIBE_FLAG(PR_PAC_APDAKEY);
		DESCRIBE_FLAG(PR_PAC_APDBKEY);
		DESCRIBE_FLAG(PR_PAC_APGAKEY);
		return describe_end(value, desc);
		}

		static const char* abi_string(const Tombstone& tombstone) {
		switch (tombstone.arch()) {
		case Architecture::ARM32: