Snap for 4476081 from 4e391dc209d1ca95ad3cdaa658452bf018e8c4df to pi-release (31b97b53) · Commits · e / os / android_system_core

adb/sysdeps.h

+1 −15

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

		// Include this before open/close/unlink are defined as macros below.
		#include <android-base/errors.h>
		#include <android-base/macros.h>
		#include <android-base/unique_fd.h>
		#include <android-base/utf8.h>

		@@ -38,21 +39,6 @@
		#include "sysdeps/network.h"
		#include "sysdeps/stat.h"

		/*
		* TEMP_FAILURE_RETRY is defined by some, but not all, versions of
		* <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's
		* not already defined, then define it here.
		*/
		#ifndef TEMP_FAILURE_RETRY
		/* Used to retry syscalls that can return EINTR. */
		#define TEMP_FAILURE_RETRY(exp) ({ \
		typeof (exp) _rc; \
		do { \
		_rc = (exp); \
		} while (_rc == -1 && errno == EINTR); \
		_rc; })
		#endif

		// Some printf-like functions are implemented in terms of
		// android::base::StringAppendV, so they should use the same attribute for
		// compile-time format string checking. On Windows, if the mingw version of

bootstat/bootstat.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -228,6 +228,13 @@ const std::map<std::string, int32_t> kBootReasonMap = {
		{"reboot,its_just_so_hard", 88}, // produced by boot_reason_test
		{"reboot,Its Just So Hard", 89}, // produced by boot_reason_test
		{"usb", 90},
		{"charge", 91},
		{"oem_tz_crash", 92},
		{"uvlo", 93},
		{"oem_ps_hold", 94},
		{"abnormal_reset", 95},
		{"oemerr_unknown", 96},
		{"reboot_fastboot_mode", 97},
		};

		// Converts a string value representing the reason the system booted to an

gatekeeperd/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ LOCAL_SHARED_LIBRARIES := \
		libbase \
		libutils \
		libcrypto \
		libkeystore_aidl \
		libkeystore_binder \
		libhidlbase \
		libhidltransport \

libbacktrace/UnwindStackMap.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -44,15 +44,15 @@ bool UnwindStackMap::Build() {
		}

		// Iterate through the maps and fill in the backtrace_map_t structure.
		for (auto& map_info : *stack_maps_) {
		for (auto* map_info : *stack_maps_) {
		backtrace_map_t map;
		map.start = map_info.start;
		map.end = map_info.end;
		map.offset = map_info.offset;
		map.start = map_info->start;
		map.end = map_info->end;
		map.offset = map_info->offset;
		// Set to -1 so that it is demand loaded.
		map.load_bias = static_cast<uintptr_t>(-1);
		map.flags = map_info.flags;
		map.name = map_info.name;
		map.flags = map_info->flags;
		map.name = map_info->name;

		maps_.push_back(map);
		}

libbacktrace/backtrace_test.cpp

+14 −43

Original line number	Diff line number	Diff line
		@@ -77,6 +77,7 @@ struct thread_t {

		struct dump_thread_t {
		thread_t thread;
		BacktraceMap* map;
		Backtrace* backtrace;
		int32_t* now;
		int32_t done;
		@@ -632,7 +633,7 @@ static void* ThreadDump(void* data) {
		}

		// The status of the actual unwind will be checked elsewhere.
		dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid);
		dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid, dump->map);
		dump->backtrace->Unwind(0);

		android_atomic_acquire_store(1, &dump->done);
		@@ -640,8 +641,8 @@ static void* ThreadDump(void* data) {
		return nullptr;
		}

		TEST(libbacktrace, thread_multiple_dump) {
		// Dump NUM_THREADS simultaneously.
		static void MultipleThreadDumpTest(bool share_map) {
		// Dump NUM_THREADS simultaneously using the same map.
		std::vector<thread_t> runners(NUM_THREADS);
		std::vector<dump_thread_t> dumpers(NUM_THREADS);

		@@ -662,12 +663,17 @@ TEST(libbacktrace, thread_multiple_dump) {

		// Start all of the dumpers at once, they will spin until they are signalled
		// to begin their dump run.
		std::unique_ptr<BacktraceMap> map;
		if (share_map) {
		map.reset(BacktraceMap::Create(getpid()));
		}
		int32_t dump_now = 0;
		for (size_t i = 0; i < NUM_THREADS; i++) {
		dumpers[i].thread.tid = runners[i].tid;
		dumpers[i].thread.state = 0;
		dumpers[i].done = 0;
		dumpers[i].now = &dump_now;
		dumpers[i].map = map.get();

		ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
		}
		@@ -689,47 +695,12 @@ TEST(libbacktrace, thread_multiple_dump) {
		}
		}

		TEST(libbacktrace, thread_multiple_dump_same_thread) {
		pthread_attr_t attr;
		pthread_attr_init(&attr);
		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
		thread_t runner;
		runner.tid = 0;
		runner.state = 0;
		ASSERT_TRUE(pthread_create(&runner.threadId, &attr, ThreadMaxRun, &runner) == 0);

		// Wait for tids to be set.
		ASSERT_TRUE(WaitForNonZero(&runner.state, 30));

		// Start all of the dumpers at once, they will spin until they are signalled
		// to begin their dump run.
		int32_t dump_now = 0;
		// Dump the same thread NUM_THREADS simultaneously.
		std::vector<dump_thread_t> dumpers(NUM_THREADS);
		for (size_t i = 0; i < NUM_THREADS; i++) {
		dumpers[i].thread.tid = runner.tid;
		dumpers[i].thread.state = 0;
		dumpers[i].done = 0;
		dumpers[i].now = &dump_now;

		ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
		}

		// Start all of the dumpers going at once.
		android_atomic_acquire_store(1, &dump_now);

		for (size_t i = 0; i < NUM_THREADS; i++) {
		ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 30));

		ASSERT_TRUE(dumpers[i].backtrace != nullptr);
		VerifyMaxDump(dumpers[i].backtrace);

		delete dumpers[i].backtrace;
		dumpers[i].backtrace = nullptr;
		TEST(libbacktrace, thread_multiple_dump) {
		MultipleThreadDumpTest(false);
		}

		// Tell the runner thread to exit its infinite loop.
		android_atomic_acquire_store(0, &runner.state);
		TEST(libbacktrace, thread_multiple_dump_same_map) {
		MultipleThreadDumpTest(true);
		}

		// This test is for UnwindMaps that should share the same map cursor when