release-request-46bf7ca6-57e7-44b8-8edc-ea8830c1cb3b-for-git_oc-mr1-release-40... (3970f2e0) · Commits · e / os / android_system_core

debuggerd/debuggerd_test.cpp

+76 −6

Original line number	Diff line number	Diff line
		@@ -89,7 +89,7 @@ constexpr char kWaitForGdbKey[] = "debug.debuggerd.wait_for_gdb";
		} while (0)

		static void tombstoned_intercept(pid_t target_pid, unique_fd* intercept_fd, unique_fd* output_fd,
		DebuggerdDumpType intercept_type) {
		InterceptStatus* status, DebuggerdDumpType intercept_type) {
		intercept_fd->reset(socket_local_client(kTombstonedInterceptSocketName,
		ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET));
		if (intercept_fd->get() == -1) {
		@@ -136,7 +136,7 @@ static void tombstoned_intercept(pid_t target_pid, unique_fd* intercept_fd, uniq
		<< ", received " << rc;
		}

		ASSERT_EQ(InterceptStatus::kRegistered, response.status);
		*status = response.status;
		}

		class CrasherTest : public ::testing::Test {
		@@ -180,7 +180,9 @@ void CrasherTest::StartIntercept(unique_fd* output_fd, DebuggerdDumpType interce
		FAIL() << "crasher hasn't been started";
		}

		tombstoned_intercept(crasher_pid, &this->intercept_fd, output_fd, intercept_type);
		InterceptStatus status;
		tombstoned_intercept(crasher_pid, &this->intercept_fd, output_fd, &status, intercept_type);
		ASSERT_EQ(InterceptStatus::kRegistered, status);
		}

		void CrasherTest::FinishIntercept(int* result) {
		@@ -598,7 +600,9 @@ TEST(tombstoned, no_notify) {
		pid_t pid = 123'456'789 + i;

		unique_fd intercept_fd, output_fd;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, kDebuggerdTombstone);
		InterceptStatus status;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		{
		unique_fd tombstoned_socket, input_fd;
		@@ -630,7 +634,9 @@ TEST(tombstoned, stress) {
		pid_t pid = pid_base + dump;

		unique_fd intercept_fd, output_fd;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, kDebuggerdTombstone);
		InterceptStatus status;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		// Pretend to crash, and then immediately close the socket.
		unique_fd sockfd(socket_local_client(kTombstonedCrashSocketName,
		@@ -661,7 +667,9 @@ TEST(tombstoned, stress) {
		pid_t pid = pid_base + dump;

		unique_fd intercept_fd, output_fd;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, kDebuggerdTombstone);
		InterceptStatus status;
		tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		{
		unique_fd tombstoned_socket, input_fd;
		@@ -685,3 +693,65 @@ TEST(tombstoned, stress) {
		thread.join();
		}
		}

		TEST(tombstoned, java_trace_intercept_smoke) {
		// Using a "real" PID is a little dangerous here - if the test fails
		// or crashes, we might end up getting a bogus / unreliable stack
		// trace.
		const pid_t self = getpid();

		unique_fd intercept_fd, output_fd;
		InterceptStatus status;
		tombstoned_intercept(self, &intercept_fd, &output_fd, &status, kDebuggerdJavaBacktrace);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		// First connect to tombstoned requesting a native backtrace. This
		// should result in a "regular" FD and not the installed intercept.
		const char native[] = "native";
		unique_fd tombstoned_socket, input_fd;
		ASSERT_TRUE(tombstoned_connect(self, &tombstoned_socket, &input_fd, kDebuggerdNativeBacktrace));
		ASSERT_TRUE(android::base::WriteFully(input_fd.get(), native, sizeof(native)));
		tombstoned_notify_completion(tombstoned_socket.get());

		// Then, connect to tombstoned asking for a java backtrace. This should
		// trigger the intercept.
		const char java[] = "java";
		ASSERT_TRUE(tombstoned_connect(self, &tombstoned_socket, &input_fd, kDebuggerdJavaBacktrace));
		ASSERT_TRUE(android::base::WriteFully(input_fd.get(), java, sizeof(java)));
		tombstoned_notify_completion(tombstoned_socket.get());

		char outbuf[sizeof(java)];
		ASSERT_TRUE(android::base::ReadFully(output_fd.get(), outbuf, sizeof(outbuf)));
		ASSERT_STREQ("java", outbuf);
		}

		TEST(tombstoned, multiple_intercepts) {
		const pid_t fake_pid = 1'234'567;
		unique_fd intercept_fd, output_fd;
		InterceptStatus status;
		tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &status, kDebuggerdJavaBacktrace);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		unique_fd intercept_fd_2, output_fd_2;
		tombstoned_intercept(fake_pid, &intercept_fd_2, &output_fd_2, &status, kDebuggerdNativeBacktrace);
		ASSERT_EQ(InterceptStatus::kFailedAlreadyRegistered, status);
		}

		TEST(tombstoned, intercept_any) {
		const pid_t fake_pid = 1'234'567;

		unique_fd intercept_fd, output_fd;
		InterceptStatus status;
		tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &status, kDebuggerdNativeBacktrace);
		ASSERT_EQ(InterceptStatus::kRegistered, status);

		const char any[] = "any";
		unique_fd tombstoned_socket, input_fd;
		ASSERT_TRUE(tombstoned_connect(fake_pid, &tombstoned_socket, &input_fd, kDebuggerdAnyIntercept));
		ASSERT_TRUE(android::base::WriteFully(input_fd.get(), any, sizeof(any)));
		tombstoned_notify_completion(tombstoned_socket.get());

		char outbuf[sizeof(any)];
		ASSERT_TRUE(android::base::ReadFully(output_fd.get(), outbuf, sizeof(outbuf)));
		ASSERT_STREQ("any", outbuf);
		}

debuggerd/tombstoned/tombstoned.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -163,7 +163,7 @@ class CrashQueue {
		};

		// Whether java trace dumps are produced via tombstoned.
		static constexpr bool kJavaTraceDumpsEnabled = false;
		static constexpr bool kJavaTraceDumpsEnabled = true;

		/* static / CrashQueue const CrashQueue::tombstone =
		new CrashQueue("/data/tombstones", "tombstone_" /* file_name_prefix /, 10 / max_artifacts */,

fs_mgr/fs_mgr_fstab.cpp

+2 −10

Original line number	Diff line number	Diff line
		@@ -389,16 +389,8 @@ static std::string read_fstab_from_dt() {

		dirent* dp;
		while ((dp = readdir(fstabdir.get())) != NULL) {
		// skip over name and compatible
		if (dp->d_type != DT_DIR) {
		continue;
		}

		// skip if its not 'vendor', 'odm' or 'system'
		if (strcmp(dp->d_name, "odm") && strcmp(dp->d_name, "system") &&
		strcmp(dp->d_name, "vendor")) {
		continue;
		}
		// skip over name, compatible and .
		if (dp->d_type != DT_DIR \|\| dp->d_name[0] == '.') continue;

		// create <dev> <mnt_point> <type> <mnt_flags> <fsmgr_flags>\n
		std::vector<std::string> fstab_entry;

fs_mgr/fs_mgr_verity.cpp

+41 −14

Original line number	Diff line number	Diff line
		@@ -689,27 +689,55 @@ int load_verity_state(struct fstab_rec* fstab, int* mode) {
		return read_verity_state(fstab->verity_loc, offset, mode);
		}

		static void update_verity_table_blk_device(char blk_device, char *table)
		{
		std::string result, word;
		// Update the verity table using the actual block device path.
		// Two cases:
		// Case-1: verity table is shared for devices with different by-name prefix.
		// Example:
		// verity table token: /dev/block/bootdevice/by-name/vendor
		// blk_device-1 (non-A/B): /dev/block/platform/soc.0/7824900.sdhci/by-name/vendor
		// blk_device-2 (A/B): /dev/block/platform/soc.0/f9824900.sdhci/by-name/vendor_a
		//
		// Case-2: append A/B suffix in the verity table.
		// Example:
		// verity table token: /dev/block/platform/soc.0/7824900.sdhci/by-name/vendor
		// blk_device: /dev/block/platform/soc.0/7824900.sdhci/by-name/vendor_a
		static void update_verity_table_blk_device(const std::string& blk_device, char** table,
		bool slot_select) {
		bool updated = false;
		std::string result, ab_suffix;
		auto tokens = android::base::Split(*table, " ");

		// If slot_select is set, it means blk_device is already updated with ab_suffix.
		if (slot_select) ab_suffix = fs_mgr_get_slot_suffix();

		for (const auto& token : tokens) {
		if (android::base::StartsWith(token, "/dev/block/") &&
		android::base::StartsWith(blk_device, token.c_str())) {
		word = blk_device;
		std::string new_token;
		if (android::base::StartsWith(token, "/dev/block/")) {
		if (token == blk_device) return; // no need to update if they're already the same.
		std::size_t found1 = blk_device.find("by-name");
		std::size_t found2 = token.find("by-name");
		if (found1 != std::string::npos && found2 != std::string::npos &&
		blk_device.substr(found1) == token.substr(found2) + ab_suffix) {
		new_token = blk_device;
		}
		}

		if (!new_token.empty()) {
		updated = true;
		LINFO << "Verity table: updated block device from '" << token << "' to '" << new_token
		<< "'";
		} else {
		word = token;
		new_token = token;
		}

		if (result.empty()) {
		result = word;
		result = new_token;
		} else {
		result += " " + word;
		result += " " + new_token;
		}
		}

		if (result.empty()) {
		if (!updated) {
		return;
		}

		@@ -825,10 +853,9 @@ int fs_mgr_setup_verity(struct fstab_rec *fstab, bool wait_for_verity_dev)
		LINFO << "Enabling dm-verity for " << mount_point.c_str()
		<< " (mode " << params.mode << ")";

		if (fstab->fs_mgr_flags & MF_SLOTSELECT) {
		// Update the verity params using the actual block device path
		update_verity_table_blk_device(fstab->blk_device, &params.table);
		}
		update_verity_table_blk_device(fstab->blk_device, &params.table,
		fstab->fs_mgr_flags & MF_SLOTSELECT);

		// load the verity mapping table
		if (load_verity_table(io, mount_point, verity.data_size, fd, &params,

init/init_first_stage.cpp

+6 −9

Original line number	Diff line number	Diff line
		@@ -60,9 +60,8 @@ class FirstStageMount {
		virtual bool SetUpDmVerity(fstab_rec* fstab_rec) = 0;

		bool need_dm_verity_;
		// Device tree fstab entries.

		std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> device_tree_fstab_;
		// Eligible first stage mount candidates, only allow /system, /vendor and/or /odm.
		std::vector<fstab_rec*> mount_fstab_recs_;
		std::set<std::string> required_devices_partition_names_;
		DeviceHandler device_handler_;
		@@ -115,12 +114,10 @@ FirstStageMount::FirstStageMount()
		LOG(ERROR) << "Failed to read fstab from device tree";
		return;
		}
		for (auto mount_point : {"/system", "/vendor", "/odm"}) {
		fstab_rec* fstab_rec =
		fs_mgr_get_entry_for_mount_point(device_tree_fstab_.get(), mount_point);
		if (fstab_rec != nullptr) {
		mount_fstab_recs_.push_back(fstab_rec);
		}
		// Stores device_tree_fstab_->recs[] into mount_fstab_recs_ (vector<fstab_rec*>)
		// for easier manipulation later, e.g., range-base for loop.
		for (int i = 0; i < device_tree_fstab_->num_entries; i++) {
		mount_fstab_recs_.push_back(&device_tree_fstab_->recs[i]);
		}
		}

		@@ -420,7 +417,7 @@ bool FirstStageMountVBootV2::InitAvbHandle() {

		// Public functions
		// ----------------
		// Mounts /system, /vendor, and/or /odm if they are present in the fstab provided by device tree.
		// Mounts partitions specified by fstab in device tree.
		bool DoFirstStageMount() {
		// Skips first stage mount if we're in recovery mode.
		if (IsRecoveryMode()) {