Merge "libsnapshot: update opcountcheck" into main
diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp
index bd1e91d..af1bb81 100644
--- a/debuggerd/client/debuggerd_client.cpp
+++ b/debuggerd/client/debuggerd_client.cpp
@@ -116,7 +116,6 @@
bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int timeout_ms,
unique_fd output_fd) {
- pid_t pid = tid;
if (dump_type == kDebuggerdJavaBacktrace) {
// Java dumps always get sent to the tgid, so we need to resolve our tid to a tgid.
android::procinfo::ProcessInfo procinfo;
@@ -125,10 +124,10 @@
log_error(output_fd, 0, "failed to get process info: %s", error.c_str());
return false;
}
- pid = procinfo.pid;
+ tid = procinfo.pid;
}
- LOG(INFO) << TAG "started dumping process " << pid;
+ LOG(INFO) << TAG "started dumping process " << tid;
// Rather than try to deal with poll() all the way through the flow, we update
// the socket timeout between each step (and only use poll() during the final
@@ -172,7 +171,7 @@
InterceptRequest req = {
.dump_type = dump_type,
- .pid = pid,
+ .pid = tid,
};
// Create an intermediate pipe to pass to the other end.
@@ -235,8 +234,8 @@
// Send the signal.
const int signal = (dump_type == kDebuggerdJavaBacktrace) ? SIGQUIT : BIONIC_SIGNAL_DEBUGGER;
sigval val = {.sival_int = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0};
- if (sigqueue(pid, signal, val) != 0) {
- log_error(output_fd, errno, "failed to send signal to pid %d", pid);
+ if (sigqueue(tid, signal, val) != 0) {
+ log_error(output_fd, errno, "failed to send signal to pid %d", tid);
return false;
}
@@ -299,7 +298,7 @@
}
}
- LOG(INFO) << TAG "done dumping process " << pid;
+ LOG(INFO) << TAG "done dumping process " << tid;
return true;
}
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 0899111..a23a269 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -322,6 +322,7 @@
process_info->scudo_ring_buffer = crash_info->data.d.scudo_ring_buffer;
process_info->scudo_ring_buffer_size = crash_info->data.d.scudo_ring_buffer_size;
*recoverable_gwp_asan_crash = crash_info->data.d.recoverable_gwp_asan_crash;
+ process_info->crash_detail_page = crash_info->data.d.crash_detail_page;
FALLTHROUGH_INTENDED;
case 1:
case 2:
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index c0522aa..f396b1d 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -37,6 +37,7 @@
#include <string>
#include <thread>
+#include <android/crash_detail.h>
#include <android/dlext.h>
#include <android/fdsan.h>
#include <android/set_abort_message.h>
@@ -939,6 +940,233 @@
ASSERT_MATCH(result, R"(Abort message: 'x{4045}')");
}
+static char g_crash_detail_value_changes[] = "crash_detail_value";
+static char g_crash_detail_value[] = "crash_detail_value";
+static char g_crash_detail_value2[] = "crash_detail_value2";
+
+inline crash_detail_t* _Nullable android_register_crash_detail_strs(const char* _Nonnull name,
+ const char* _Nonnull data) {
+ return android_crash_detail_register(name, strlen(name), data, strlen(data));
+}
+
+TEST_F(CrasherTest, crash_detail_single) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+}
+
+TEST_F(CrasherTest, crash_detail_replace_data) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ auto *cd = android_register_crash_detail_strs("CRASH_DETAIL_NAME", "original_data");
+ android_crash_detail_replace_data(cd, "new_data", strlen("new_data"));
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'new_data')");
+ // Ensure the old one no longer shows up, i.e. that we actually replaced
+ // it, not added a new one.
+ ASSERT_NOT_MATCH(result, R"(CRASH_DETAIL_NAME: 'original_data')");
+}
+
+TEST_F(CrasherTest, crash_detail_replace_name) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ auto *cd = android_register_crash_detail_strs("old_name", g_crash_detail_value);
+ android_crash_detail_replace_name(cd, "new_name", strlen("new_name"));
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(new_name: 'crash_detail_value')");
+ // Ensure the old one no longer shows up, i.e. that we actually replaced
+ // it, not added a new one.
+ ASSERT_NOT_MATCH(result, R"(old_name: 'crash_detail_value')");
+}
+
+TEST_F(CrasherTest, crash_detail_single_byte_name) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME\1", g_crash_detail_value);
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME\\1: 'crash_detail_value')");
+}
+
+
+TEST_F(CrasherTest, crash_detail_single_bytes) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ android_crash_detail_register("CRASH_DETAIL_NAME", strlen("CRASH_DETAIL_NAME"), "\1",
+ sizeof("\1"));
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: '\\1\\0')");
+}
+
+TEST_F(CrasherTest, crash_detail_mixed) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ const char data[] = "helloworld\1\255\3";
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME", data);
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'helloworld\\1\\255\\3')");
+}
+
+TEST_F(CrasherTest, crash_detail_many) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ for (int i = 0; i < 1000; ++i) {
+ std::string name = "CRASH_DETAIL_NAME" + std::to_string(i);
+ std::string value = "CRASH_DETAIL_VALUE" + std::to_string(i);
+ auto* h = android_register_crash_detail_strs(name.data(), value.data());
+ android_crash_detail_unregister(h);
+ }
+
+ android_register_crash_detail_strs("FINAL_NAME", "FINAL_VALUE");
+ android_register_crash_detail_strs("FINAL_NAME2", "FINAL_VALUE2");
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_NOT_MATCH(result, "CRASH_DETAIL_NAME");
+ ASSERT_NOT_MATCH(result, "CRASH_DETAIL_VALUE");
+ ASSERT_MATCH(result, R"(FINAL_NAME: 'FINAL_VALUE')");
+ ASSERT_MATCH(result, R"(FINAL_NAME2: 'FINAL_VALUE2')");
+}
+
+TEST_F(CrasherTest, crash_detail_single_changes) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value_changes);
+ g_crash_detail_value_changes[0] = 'C';
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'Crash_detail_value')");
+}
+
+TEST_F(CrasherTest, crash_detail_multiple) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME2", g_crash_detail_value2);
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME2: 'crash_detail_value2')");
+}
+
+TEST_F(CrasherTest, crash_detail_remove) {
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([]() {
+ auto* detail1 = android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+ android_crash_detail_unregister(detail1);
+ android_register_crash_detail_strs("CRASH_DETAIL_NAME2", g_crash_detail_value2);
+ abort();
+ });
+ StartIntercept(&output_fd);
+ FinishCrasher();
+ AssertDeath(SIGABRT);
+ FinishIntercept(&intercept_result);
+
+ ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+ std::string result;
+ ConsumeFd(std::move(output_fd), &result);
+ ASSERT_NOT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+ ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME2: 'crash_detail_value2')");
+}
+
TEST_F(CrasherTest, abort_message_newline_trimmed) {
int intercept_result;
unique_fd output_fd;
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index ea07ce2..141723b 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -397,6 +397,7 @@
ASSERT_SAME_OFFSET(scudo_ring_buffer_size, scudo_ring_buffer_size);
ASSERT_SAME_OFFSET(scudo_stack_depot_size, scudo_stack_depot_size);
ASSERT_SAME_OFFSET(recoverable_gwp_asan_crash, recoverable_gwp_asan_crash);
+ ASSERT_SAME_OFFSET(crash_detail_page, crash_detail_page);
#undef ASSERT_SAME_OFFSET
iovs[3] = {.iov_base = &thread_info->process_info,
diff --git a/debuggerd/include/debuggerd/client.h b/debuggerd/include/debuggerd/client.h
index b7284b0..e7401cc 100644
--- a/debuggerd/include/debuggerd/client.h
+++ b/debuggerd/include/debuggerd/client.h
@@ -26,7 +26,7 @@
// Trigger a dump of specified process to output_fd.
// output_fd is consumed, timeout of 0 will wait forever.
-bool debuggerd_trigger_dump(pid_t pid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
+bool debuggerd_trigger_dump(pid_t tid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
android::base::unique_fd output_fd);
int dump_backtrace_to_file(pid_t tid, enum DebuggerdDumpType dump_type, int output_fd);
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index de12fc6..c18cf6e 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -33,6 +33,8 @@
struct AllocationMetadata;
}; // namespace gwp_asan
+struct crash_detail_page_t;
+
// When updating this data structure, CrashInfoDataDynamic and the code in
// ReadCrashInfo() must also be updated.
struct __attribute__((packed)) debugger_process_info {
@@ -46,6 +48,7 @@
size_t scudo_ring_buffer_size;
size_t scudo_stack_depot_size;
bool recoverable_gwp_asan_crash;
+ struct crash_detail_page_t* crash_detail_page;
};
// GWP-ASan calbacks to support the recoverable mode. Separate from the
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 075b12c..4d69658 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -56,4 +56,5 @@
bool has_fault_address = false;
uintptr_t untagged_fault_address = 0;
uintptr_t maybe_tagged_fault_address = 0;
+ uintptr_t crash_detail_page = 0;
};
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index ac92ac0..a4c08a4 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -118,3 +118,19 @@
"LOG pac_enabled_keys: 0000000000001009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown "
"0x1000\\)\\n");
}
+
+TEST_F(TombstoneProtoToTextTest, crash_detail_string) {
+ auto* crash_detail = tombstone_->add_crash_details();
+ crash_detail->set_name("CRASH_DETAIL_NAME");
+ crash_detail->set_data("crash_detail_value");
+ ProtoToString();
+ EXPECT_MATCH(text_, "(CRASH_DETAIL_NAME: 'crash_detail_value')");
+}
+
+TEST_F(TombstoneProtoToTextTest, crash_detail_bytes) {
+ auto* crash_detail = tombstone_->add_crash_details();
+ crash_detail->set_name("CRASH_DETAIL_NAME");
+ crash_detail->set_data("helloworld\1\255\3");
+ ProtoToString();
+ EXPECT_MATCH(text_, R"(CRASH_DETAIL_NAME: 'helloworld\\1\\255\\3')");
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 744bfab..74f9a8c 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -48,8 +48,10 @@
#include <android-base/unique_fd.h>
#include <android/log.h>
+#include <android/set_abort_message.h>
#include <bionic/macros.h>
#include <bionic/reserved_signals.h>
+#include <bionic/crash_detail_internal.h>
#include <log/log.h>
#include <log/log_read.h>
#include <log/logprint.h>
@@ -94,6 +96,11 @@
static std::optional<std::string> get_stack_overflow_cause(uint64_t fault_addr, uint64_t sp,
unwindstack::Maps* maps) {
+ // Under stack MTE the stack pointer and/or the fault address can be tagged.
+ // In order to calculate deltas between them, strip off the tags off both
+ // addresses.
+ fault_addr = untag_address(fault_addr);
+ sp = untag_address(sp);
static constexpr uint64_t kMaxDifferenceBytes = 256;
uint64_t difference;
if (sp >= fault_addr) {
@@ -251,6 +258,46 @@
}
}
+static void dump_crash_details(Tombstone* tombstone,
+ std::shared_ptr<unwindstack::Memory>& process_memory,
+ const ProcessInfo& process_info) {
+ uintptr_t address = process_info.crash_detail_page;
+ while (address) {
+ struct crash_detail_page_t page;
+ if (!process_memory->ReadFully(address, &page, sizeof(page))) {
+ async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "failed to read crash detail page: %m");
+ break;
+ }
+ if (page.used > kNumCrashDetails) {
+ async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "crash detail: page corrupted");
+ break;
+ }
+ for (size_t i = 0; i < page.used; ++i) {
+ const crash_detail_t& crash_detail = page.crash_details[i];
+ if (!crash_detail.data) {
+ continue;
+ }
+ std::string name(crash_detail.name_size, '\0');
+ if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(crash_detail.name), name.data(),
+ crash_detail.name_size)) {
+ async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "crash detail: failed to read name: %m");
+ continue;
+ }
+ std::string data(crash_detail.data_size, '\0');
+ if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(crash_detail.data), data.data(),
+ crash_detail.data_size)) {
+ async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+ "crash detail: failed to read data for %s: %m", name.c_str());
+ continue;
+ }
+ auto* proto_detail = tombstone->add_crash_details();
+ proto_detail->set_name(name);
+ proto_detail->set_data(data);
+ }
+ address = reinterpret_cast<uintptr_t>(page.prev);
+ }
+}
+
static void dump_abort_message(Tombstone* tombstone,
std::shared_ptr<unwindstack::Memory>& process_memory,
const ProcessInfo& process_info) {
@@ -698,7 +745,7 @@
*result.mutable_signal_info() = sig;
dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
-
+ dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
// Dump the main thread, but save the memory around the registers.
dump_thread(&result, unwinder, main_thread, /* memory_dump */ true);
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index ad91320..cefa2d6 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -18,7 +18,9 @@
#include <inttypes.h>
+#include <charconv>
#include <functional>
+#include <limits>
#include <set>
#include <string>
#include <unordered_set>
@@ -425,6 +427,27 @@
}
}
+static std::string oct_encode(const std::string& data) {
+ std::string oct_encoded;
+ oct_encoded.reserve(data.size());
+
+ // N.B. the unsigned here is very important, otherwise e.g. \255 would render as
+ // \-123 (and overflow our buffer).
+ for (unsigned char c : data) {
+ if (isprint(c)) {
+ oct_encoded += c;
+ } else {
+ std::string oct_digits("\\\0\0\0", 4);
+ // char is encodable in 3 oct digits
+ static_assert(std::numeric_limits<unsigned char>::max() <= 8 * 8 * 8);
+ auto [ptr, ec] = std::to_chars(oct_digits.data() + 1, oct_digits.data() + 4, c, 8);
+ oct_digits.resize(ptr - oct_digits.data());
+ oct_encoded += oct_digits;
+ }
+ }
+ return oct_encoded;
+}
+
static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
const Thread& thread) {
print_thread_header(callback, tombstone, thread, true);
@@ -468,6 +491,12 @@
CBL("Abort message: '%s'", tombstone.abort_message().c_str());
}
+ for (const auto& crash_detail : tombstone.crash_details()) {
+ std::string oct_encoded_name = oct_encode(crash_detail.name());
+ std::string oct_encoded_data = oct_encode(crash_detail.data());
+ CBL("Extra crash detail: %s: '%s'", oct_encoded_name.c_str(), oct_encoded_data.c_str());
+ }
+
print_thread_registers(callback, tombstone, thread, true);
if (is_async_mte_crash) {
CBL("Note: This crash is a delayed async MTE crash. Memory corruption has occurred");
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 49865a2..214cbfb 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -15,6 +15,11 @@
// NOTE TO OEMS:
// If you add custom fields to this proto, do not use numbers in the reserved range.
+message CrashDetail {
+ bytes name = 1;
+ bytes data = 2;
+}
+
message Tombstone {
Architecture arch = 1;
string build_fingerprint = 2;
@@ -33,6 +38,7 @@
Signal signal_info = 10;
string abort_message = 14;
+ repeated CrashDetail crash_details = 21;
repeated Cause causes = 15;
map<uint32, Thread> threads = 16;
@@ -40,7 +46,7 @@
repeated LogBuffer log_buffers = 18;
repeated FD open_fds = 19;
- reserved 21 to 999;
+ reserved 22 to 999;
}
enum Architecture {
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index 793428a..d3fc15e 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -101,6 +101,7 @@
size_t scudo_ring_buffer_size;
size_t scudo_stack_depot_size;
bool recoverable_gwp_asan_crash;
+ uintptr_t crash_detail_page;
};
struct __attribute__((__packed__)) CrashInfo {
diff --git a/debuggerd/seccomp_policy/crash_dump.arm64.policy b/debuggerd/seccomp_policy/crash_dump.arm64.policy
index adf8738..c5d10d6 100644
--- a/debuggerd/seccomp_policy/crash_dump.arm64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.arm64.policy
@@ -28,11 +28,11 @@
rt_tgsigqueueinfo: 1
prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == 0x53564d41 || arg0 == PR_PAC_RESET_KEYS || arg0 == 56 || arg0 == 61
madvise: 1
-mprotect: arg2 in 0x1|0x2
+mprotect: arg2 in 0x1|0x2|0x20
munmap: 1
getuid: 1
fstat: 1
-mmap: arg2 in 0x1|0x2
+mmap: arg2 in 0x1|0x2|0x20
geteuid: 1
getgid: 1
getegid: 1
diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index 72e326a..03af8f7 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -83,7 +83,18 @@
// be reliable.
// 256KiB seems to work, but 1MiB bulk transfers lock up my z620 with a 3.13
// kernel.
-#define MAX_USBFS_BULK_SIZE (16 * 1024)
+// 128KiB was experimentally found to be enough to saturate the bus at
+// SuperSpeed+, so we first try double that for writes. If the operation fails
+// due to a lack of contiguous regions (or an ancient kernel), try smaller sizes
+// until we find one that works (see LinuxUsbTransport::Write). Reads are less
+// performance critical so for now just use a known good size.
+#define MAX_USBFS_BULK_WRITE_SIZE (256 * 1024)
+#define MAX_USBFS_BULK_READ_SIZE (16 * 1024)
+
+// This size should pretty much always work (it's compatible with pre-3.3
+// kernels and it's what we used to use historically), so if it doesn't work
+// something has gone badly wrong.
+#define MIN_USBFS_BULK_WRITE_SIZE (16 * 1024)
struct usb_handle
{
@@ -108,6 +119,7 @@
private:
std::unique_ptr<usb_handle> handle_;
const uint32_t ms_timeout_;
+ size_t max_usbfs_bulk_write_size_ = MAX_USBFS_BULK_WRITE_SIZE;
DISALLOW_COPY_AND_ASSIGN(LinuxUsbTransport);
};
@@ -415,26 +427,32 @@
}
auto submit_urb = [&](size_t i) {
- int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+ while (true) {
+ int xfer = (len > max_usbfs_bulk_write_size_) ? max_usbfs_bulk_write_size_ : len;
- urb[i].type = USBDEVFS_URB_TYPE_BULK;
- urb[i].endpoint = handle_->ep_out;
- urb[i].buffer_length = xfer;
- urb[i].buffer = data;
- urb[i].usercontext = (void *)i;
+ urb[i].type = USBDEVFS_URB_TYPE_BULK;
+ urb[i].endpoint = handle_->ep_out;
+ urb[i].buffer_length = xfer;
+ urb[i].buffer = data;
+ urb[i].usercontext = (void *)i;
- int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
- if (n != 0) {
- DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
- return false;
+ int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
+ if (n != 0) {
+ if (errno == ENOMEM && max_usbfs_bulk_write_size_ > MIN_USBFS_BULK_WRITE_SIZE) {
+ max_usbfs_bulk_write_size_ /= 2;
+ continue;
+ }
+ DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
+ return false;
+ }
+
+ pending[i] = true;
+ count += xfer;
+ len -= xfer;
+ data += xfer;
+
+ return true;
}
-
- pending[i] = true;
- count += xfer;
- len -= xfer;
- data += xfer;
-
- return true;
};
auto reap_urb = [&](size_t i) {
@@ -500,7 +518,7 @@
}
while (len > 0) {
- int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+ int xfer = (len > MAX_USBFS_BULK_READ_SIZE) ? MAX_USBFS_BULK_READ_SIZE : len;
bulk.ep = handle_->ep_in;
bulk.len = xfer;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index efb1035..5497b72 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -71,6 +71,8 @@
const int kNumThreads = 6;
const size_t kBlockSizeToRead = 1_MiB;
+ const size_t compression_factor_ = 64_KiB;
+ size_t replace_ops_ = 0, copy_ops_ = 0, zero_ops_ = 0, in_place_ops_ = 0;
std::unordered_map<std::string, int> source_block_hash_;
std::mutex source_block_hash_lock_;
@@ -81,7 +83,12 @@
std::unique_ptr<uint8_t[]> zblock_;
std::string compression_ = "lz4";
- unique_fd fd_;
+ unique_fd cow_fd_;
+ unique_fd target_fd_;
+
+ std::vector<uint64_t> zero_blocks_;
+ std::vector<uint64_t> replace_blocks_;
+ std::unordered_map<uint64_t, uint64_t> copy_blocks_;
const int BLOCK_SZ = 4_KiB;
void SHA256(const void* data, size_t length, uint8_t out[32]);
@@ -93,7 +100,14 @@
bool FindSourceBlockHash();
bool PrepareParse(std::string& parsing_file, const bool createSnapshot);
bool ParsePartition();
- bool WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash);
+ void PrepareMergeBlock(const void* buffer, uint64_t block, std::string& block_hash);
+ bool WriteV3Snapshots();
+ size_t PrepareWrite(size_t* pending_ops, size_t start_index);
+
+ bool CreateSnapshotWriter();
+ bool WriteOrderedSnapshots();
+ bool WriteNonOrderedSnapshots();
+ bool VerifyMergeOrder();
};
void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity severity, const char*,
@@ -118,21 +132,19 @@
create_snapshot_patch_ = createSnapshot;
if (createSnapshot) {
- fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
- if (fd_ < 0) {
+ cow_fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
+ if (cow_fd_ < 0) {
PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
return false;
}
+ target_fd_.reset((open(parsing_file_.c_str(), O_RDONLY)));
+ if (target_fd_ < 0) {
+ LOG(ERROR) << "open failed: " << parsing_file_;
+ return false;
+ }
zblock_ = std::make_unique<uint8_t[]>(BLOCK_SZ);
std::memset(zblock_.get(), 0, BLOCK_SZ);
-
- CowOptions options;
- options.compression = compression_;
- options.num_compress_threads = 2;
- options.batch_write = true;
- options.cluster_ops = 600;
- writer_ = CreateCowWriter(2, options, std::move(fd_));
}
return true;
}
@@ -187,19 +199,158 @@
return out;
}
-bool CreateSnapshot::WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash) {
+void CreateSnapshot::PrepareMergeBlock(const void* buffer, uint64_t block,
+ std::string& block_hash) {
if (std::memcmp(zblock_.get(), buffer, BLOCK_SZ) == 0) {
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddZeroBlocks(block, 1);
+ zero_blocks_.push_back(block);
+ return;
}
auto iter = source_block_hash_.find(block_hash);
if (iter != source_block_hash_.end()) {
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddCopy(block, iter->second, 1);
+ // In-place copy is skipped
+ if (block != iter->second) {
+ copy_blocks_[block] = iter->second;
+ } else {
+ in_place_ops_ += 1;
+ }
+ return;
}
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddRawBlocks(block, buffer, BLOCK_SZ);
+ replace_blocks_.push_back(block);
+}
+
+size_t CreateSnapshot::PrepareWrite(size_t* pending_ops, size_t start_index) {
+ size_t num_ops = *pending_ops;
+ uint64_t start_block = replace_blocks_[start_index];
+ size_t nr_consecutive = 1;
+ num_ops -= 1;
+ while (num_ops) {
+ uint64_t next_block = replace_blocks_[start_index + nr_consecutive];
+ if (next_block != start_block + nr_consecutive) {
+ break;
+ }
+ nr_consecutive += 1;
+ num_ops -= 1;
+ }
+ return nr_consecutive;
+}
+
+bool CreateSnapshot::CreateSnapshotWriter() {
+ uint64_t dev_sz = lseek(target_fd_.get(), 0, SEEK_END);
+ CowOptions options;
+ options.compression = compression_;
+ options.num_compress_threads = 2;
+ options.batch_write = true;
+ options.cluster_ops = 600;
+ options.compression_factor = compression_factor_;
+ options.max_blocks = {dev_sz / options.block_size};
+ writer_ = CreateCowWriter(3, options, std::move(cow_fd_));
+ return true;
+}
+
+bool CreateSnapshot::WriteNonOrderedSnapshots() {
+ zero_ops_ = zero_blocks_.size();
+ for (auto it = zero_blocks_.begin(); it != zero_blocks_.end(); it++) {
+ if (!writer_->AddZeroBlocks(*it, 1)) {
+ return false;
+ }
+ }
+ std::string buffer(compression_factor_, '\0');
+
+ replace_ops_ = replace_blocks_.size();
+ size_t blocks_to_compress = replace_blocks_.size();
+ size_t num_ops = 0;
+ size_t block_index = 0;
+ while (blocks_to_compress) {
+ num_ops = std::min((compression_factor_ / BLOCK_SZ), blocks_to_compress);
+ auto linear_blocks = PrepareWrite(&num_ops, block_index);
+ if (!android::base::ReadFullyAtOffset(target_fd_.get(), buffer.data(),
+ (linear_blocks * BLOCK_SZ),
+ replace_blocks_[block_index] * BLOCK_SZ)) {
+ LOG(ERROR) << "Failed to read at offset: " << replace_blocks_[block_index] * BLOCK_SZ
+ << " size: " << linear_blocks * BLOCK_SZ;
+ return false;
+ }
+ if (!writer_->AddRawBlocks(replace_blocks_[block_index], buffer.data(),
+ linear_blocks * BLOCK_SZ)) {
+ LOG(ERROR) << "AddRawBlocks failed";
+ return false;
+ }
+
+ block_index += linear_blocks;
+ blocks_to_compress -= linear_blocks;
+ }
+ if (!writer_->Finalize()) {
+ return false;
+ }
+ return true;
+}
+
+bool CreateSnapshot::WriteOrderedSnapshots() {
+ std::unordered_map<uint64_t, uint64_t> overwritten_blocks;
+ std::vector<std::pair<uint64_t, uint64_t>> merge_sequence;
+ for (auto it = copy_blocks_.begin(); it != copy_blocks_.end(); it++) {
+ if (overwritten_blocks.count(it->second)) {
+ replace_blocks_.push_back(it->first);
+ continue;
+ }
+ overwritten_blocks[it->first] = it->second;
+ merge_sequence.emplace_back(std::make_pair(it->first, it->second));
+ }
+ // Sort the blocks so that if the blocks are contiguous, it would help
+ // compress multiple blocks in one shot based on the compression factor.
+ std::sort(replace_blocks_.begin(), replace_blocks_.end());
+
+ copy_ops_ = merge_sequence.size();
+ for (auto it = merge_sequence.begin(); it != merge_sequence.end(); it++) {
+ if (!writer_->AddCopy(it->first, it->second, 1)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool CreateSnapshot::VerifyMergeOrder() {
+ unique_fd read_fd;
+ read_fd.reset(open(patch_file_.c_str(), O_RDONLY));
+ if (read_fd < 0) {
+ PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
+ return false;
+ }
+ CowReader reader;
+ if (!reader.Parse(read_fd)) {
+ LOG(ERROR) << "Parse failed";
+ return false;
+ }
+
+ if (!reader.VerifyMergeOps()) {
+ LOG(ERROR) << "MergeOps Order is wrong";
+ return false;
+ }
+ return true;
+}
+
+bool CreateSnapshot::WriteV3Snapshots() {
+ if (!CreateSnapshotWriter()) {
+ return false;
+ }
+ if (!WriteOrderedSnapshots()) {
+ return false;
+ }
+ if (!WriteNonOrderedSnapshots()) {
+ return false;
+ }
+ if (!VerifyMergeOrder()) {
+ return false;
+ }
+
+ LOG(INFO) << "In-place: " << in_place_ops_ << " Zero: " << zero_ops_
+ << " Replace: " << replace_ops_ << " copy: " << copy_ops_;
+ return true;
}
bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint64_t dev_sz) {
@@ -241,10 +392,7 @@
std::string hash = ToHexString(checksum, sizeof(checksum));
if (create_snapshot_patch_) {
- if (!WriteSnapshot(bufptr, blkindex, hash)) {
- LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
- return false;
- }
+ PrepareMergeBlock(bufptr, blkindex, hash);
} else {
std::lock_guard<std::mutex> lock(source_block_hash_lock_);
{
@@ -306,8 +454,8 @@
ret = t.get() && ret;
}
- if (ret && create_snapshot_patch_ && !writer_->Finalize()) {
- LOG(ERROR) << "Finzalize failed";
+ if (ret && create_snapshot_patch_ && !WriteV3Snapshots()) {
+ LOG(ERROR) << "Snapshot Write failed";
return false;
}
diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index fbdf5fe..b8bb586 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -530,7 +530,7 @@
props.chargerAcOnline ? "a" : "", props.chargerUsbOnline ? "u" : "",
props.chargerWirelessOnline ? "w" : "", props.chargerDockOnline ? "d" : "");
- KLOG_DEBUG(LOG_TAG, "%s\n", dmesgline);
+ KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);
}
void BatteryMonitor::logValues(const HealthInfo_2_1& health_info,
diff --git a/init/Android.bp b/init/Android.bp
index 181de2e..2d16f60 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -88,7 +88,6 @@
init_host_sources = [
"check_builtins.cpp",
"host_import_parser.cpp",
- "host_init_verifier.cpp",
]
soong_config_module_type {
@@ -321,7 +320,6 @@
visibility: ["//packages/modules/Virtualization/microdroid"],
}
-
soong_config_module_type {
name: "init_first_stage_cc_defaults",
module_type: "cc_defaults",
@@ -614,13 +612,13 @@
cc_binary {
name: "host_init_verifier",
defaults: ["init_host_defaults"],
- srcs: init_common_sources + init_host_sources,
+ srcs: ["host_init_verifier.cpp"] + init_common_sources + init_host_sources,
}
cc_library_host_static {
name: "libinit_host",
defaults: ["init_host_defaults"],
- srcs: init_common_sources,
+ srcs: init_common_sources + init_host_sources,
export_include_dirs: ["."],
proto: {
export_proto_headers: true,
diff --git a/init/check_builtins.cpp b/init/check_builtins.cpp
index 461ed22..9725458 100644
--- a/init/check_builtins.cpp
+++ b/init/check_builtins.cpp
@@ -28,9 +28,9 @@
#include <android-base/parsedouble.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
+#include <property_info_parser/property_info_parser.h>
#include "builtin_arguments.h"
-#include "host_init_verifier.h"
#include "interface_utils.h"
#include "property_type.h"
#include "rlimit_parser.h"
@@ -39,6 +39,9 @@
using android::base::ParseInt;
using android::base::StartsWith;
+using android::properties::BuildTrie;
+using android::properties::PropertyInfoArea;
+using android::properties::PropertyInfoEntry;
#define ReturnIfAnyArgsEmpty() \
for (const auto& arg : args) { \
@@ -50,6 +53,26 @@
namespace android {
namespace init {
+const PropertyInfoArea* property_info_area;
+
+Result<void> InitializeHostPropertyInfoArea(const std::vector<PropertyInfoEntry>& property_infos) {
+ static std::string serialized_contexts;
+ std::string trie_error;
+ if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
+ &trie_error)) {
+ return Error() << "Unable to serialize property contexts: " << trie_error;
+ }
+
+ property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
+ return {};
+}
+
+static Result<void> check_stub(const BuiltinArguments& args) {
+ return {};
+}
+
+#include "generated_stub_builtin_function_map.h"
+
Result<void> check_chown(const BuiltinArguments& args) {
if (!args[1].empty()) {
auto uid = DecodeUid(args[1]);
diff --git a/init/check_builtins.h b/init/check_builtins.h
index dc1b752..9b00a7c 100644
--- a/init/check_builtins.h
+++ b/init/check_builtins.h
@@ -19,6 +19,10 @@
#include "builtin_arguments.h"
#include "result.h"
+#include <vector>
+
+#include <property_info_serializer/property_info_serializer.h>
+
namespace android {
namespace init {
@@ -43,5 +47,8 @@
Result<void> check_wait(const BuiltinArguments& args);
Result<void> check_wait_for_prop(const BuiltinArguments& args);
+Result<void> InitializeHostPropertyInfoArea(
+ const std::vector<properties::PropertyInfoEntry>& property_infos);
+
} // namespace init
} // namespace android
diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index 67cac19..0076764 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -78,6 +78,7 @@
const char* args[] = {path, "/first_stage.sh", nullptr};
int rv = execv(path, const_cast<char**>(args));
LOG(ERROR) << "unable to execv /first_stage.sh, returned " << rv << " errno " << errno;
+ _exit(127);
}
namespace android {
@@ -86,7 +87,9 @@
void StartConsole(const std::string& cmdline) {
bool console = KernelConsolePresent(cmdline);
// Use a simple sigchld handler -- first_stage_console doesn't need to track or log zombies
- const struct sigaction chld_act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDWAIT };
+ const struct sigaction chld_act {
+ .sa_flags = SA_NOCLDWAIT, .sa_handler = SIG_DFL
+ };
sigaction(SIGCHLD, &chld_act, nullptr);
pid_t pid = fork();
diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index 662185c..f746ab9 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -14,8 +14,6 @@
// limitations under the License.
//
-#include "host_init_verifier.h"
-
#include <errno.h>
#include <getopt.h>
#include <pwd.h>
@@ -36,6 +34,7 @@
#include <android-base/strings.h>
#include <generated_android_ids.h>
#include <hidl/metadata.h>
+#include <property_info_parser/property_info_parser.h>
#include <property_info_serializer/property_info_serializer.h>
#include "action.h"
@@ -57,9 +56,7 @@
using android::base::ParseInt;
using android::base::ReadFileToString;
using android::base::Split;
-using android::properties::BuildTrie;
using android::properties::ParsePropertyInfoFile;
-using android::properties::PropertyInfoArea;
using android::properties::PropertyInfoEntry;
static std::vector<std::string> passwd_files;
@@ -148,12 +145,6 @@
namespace android {
namespace init {
-static Result<void> check_stub(const BuiltinArguments& args) {
- return {};
-}
-
-#include "generated_stub_builtin_function_map.h"
-
void PrintUsage() {
fprintf(stdout, R"(usage: host_init_verifier [options]
@@ -196,8 +187,6 @@
return result;
}
-const PropertyInfoArea* property_info_area;
-
void HandlePropertyContexts(const std::string& filename,
std::vector<PropertyInfoEntry>* property_infos) {
auto file_contents = std::string();
@@ -288,16 +277,11 @@
}
SetKnownInterfaces(*interface_inheritance_hierarchy_map);
- std::string serialized_contexts;
- std::string trie_error;
- if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
- &trie_error)) {
- LOG(ERROR) << "Unable to serialize property contexts: " << trie_error;
+ if (auto result = InitializeHostPropertyInfoArea(property_infos); !result.ok()) {
+ LOG(ERROR) << result.error();
return EXIT_FAILURE;
}
- property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
-
if (!partition_map.empty()) {
std::vector<std::string> vendor_prefixes;
for (const auto& partition : {"vendor", "odm"}) {
diff --git a/init/host_init_verifier.h b/init/host_init_verifier.h
deleted file mode 100644
index 5d24f2a..0000000
--- a/init/host_init_verifier.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2019 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.
- */
-
-#pragma once
-
-#include <property_info_parser/property_info_parser.h>
-
-namespace android {
-namespace init {
-
-extern const android::properties::PropertyInfoArea* property_info_area;
-
-} // namespace init
-} // namespace android
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 30ad800..bc4ef42 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1104,7 +1104,8 @@
product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
}
- vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
+ vendor_api_level =
+ std::min(AVendorSupport_getVendorApiLevelOf(product_first_api_level), vendor_api_level);
if (vendor_api_level < 0) {
LOG(ERROR) << "Unexpected vendor api level for " << VENDOR_API_LEVEL_PROP << ". Check "
diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index d158427..571b410 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -22,6 +22,8 @@
#include <sys/types.h>
#include <unistd.h>
+#include <vector>
+
#include <android-base/macros.h>
#include <android-base/unique_fd.h>
#include <cutils/ashmem.h>
@@ -61,16 +63,16 @@
EXPECT_EQ(prot, ioctl(fd, ASHMEM_GET_PROT_MASK));
}
-void FillData(uint8_t* data, size_t dataLen) {
- for (size_t i = 0; i < dataLen; i++) {
+void FillData(std::vector<uint8_t>& data) {
+ for (size_t i = 0; i < data.size(); i++) {
data[i] = i & 0xFF;
}
}
TEST(AshmemTest, BasicTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
unique_fd fd;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -78,21 +80,21 @@
void* region1 = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion1));
- memcpy(region1, &data, size);
- ASSERT_EQ(0, memcmp(region1, &data, size));
+ memcpy(region1, data.data(), size);
+ ASSERT_EQ(0, memcmp(region1, data.data(), size));
EXPECT_EQ(0, munmap(region1, size));
void *region2;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, ®ion2));
- ASSERT_EQ(0, memcmp(region2, &data, size));
+ ASSERT_EQ(0, memcmp(region2, data.data(), size));
EXPECT_EQ(0, munmap(region2, size));
}
TEST(AshmemTest, ForkTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
unique_fd fd;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -100,8 +102,8 @@
void* region1 = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion1));
- memcpy(region1, &data, size);
- ASSERT_EQ(0, memcmp(region1, &data, size));
+ memcpy(region1, data.data(), size);
+ ASSERT_EQ(0, memcmp(region1, data.data(), size));
EXPECT_EQ(0, munmap(region1, size));
ASSERT_EXIT(
@@ -113,7 +115,7 @@
if (region2 == MAP_FAILED) {
_exit(1);
}
- if (memcmp(region2, &data, size) != 0) {
+ if (memcmp(region2, data.data(), size) != 0) {
_exit(2);
}
memset(region2, 0, size);
@@ -122,10 +124,10 @@
},
::testing::ExitedWithCode(0), "");
- memset(&data, 0, size);
+ memset(data.data(), 0, size);
void *region2;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion2));
- ASSERT_EQ(0, memcmp(region2, &data, size));
+ ASSERT_EQ(0, memcmp(region2, data.data(), size));
EXPECT_EQ(0, munmap(region2, size));
}
@@ -134,18 +136,19 @@
void* region = nullptr;
// Allocate a 4-page buffer, but leave page-sized holes on either side
- constexpr size_t size = PAGE_SIZE * 4;
- constexpr size_t dataSize = PAGE_SIZE * 2;
- constexpr size_t holeSize = PAGE_SIZE;
+ const size_t pageSize = getpagesize();
+ const size_t size = pageSize * 4;
+ const size_t dataSize = pageSize * 2;
+ const size_t holeSize = pageSize;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, dataSize, PROT_READ | PROT_WRITE, ®ion, holeSize));
- uint8_t data[dataSize];
- FillData(data, dataSize);
- memcpy(region, data, dataSize);
+ std::vector<uint8_t> data(dataSize);
+ FillData(data);
+ memcpy(region, data.data(), dataSize);
- constexpr off_t dataStart = holeSize;
- constexpr off_t dataEnd = dataStart + dataSize;
+ const off_t dataStart = holeSize;
+ const off_t dataEnd = dataStart + dataSize;
// The sequence of seeks below looks something like this:
//
@@ -163,9 +166,12 @@
// Expected lseek() return value
off_t ret;
} seeks[] = {
- {99, SEEK_SET, 99}, {dataStart, SEEK_CUR, dataStart + 99},
- {0, SEEK_DATA, dataStart}, {dataStart, SEEK_HOLE, dataEnd},
- {-99, SEEK_END, size - 99}, {-dataStart, SEEK_CUR, dataEnd - 99},
+ {99, SEEK_SET, 99},
+ {dataStart, SEEK_CUR, dataStart + 99},
+ {0, SEEK_DATA, dataStart},
+ {dataStart, SEEK_HOLE, dataEnd},
+ {-99, SEEK_END, static_cast<off_t>(size) - 99},
+ {-dataStart, SEEK_CUR, dataEnd - 99},
};
for (const auto& cfg : seeks) {
errno = 0;
@@ -180,7 +186,7 @@
uint8_t buf[readSize];
ASSERT_EQ(readSize, TEMP_FAILURE_RETRY(read(fd, buf, readSize)));
- EXPECT_EQ(0, memcmp(buf, data + dataOff, readSize));
+ EXPECT_EQ(0, memcmp(buf, &data[dataOff], readSize));
}
}
@@ -189,7 +195,7 @@
TEST(AshmemTest, ProtTest) {
unique_fd fd;
- constexpr size_t size = PAGE_SIZE;
+ const size_t size = getpagesize();
void *region;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ));
@@ -217,7 +223,7 @@
TEST(AshmemTest, ForkProtTest) {
unique_fd fd;
- constexpr size_t size = PAGE_SIZE;
+ const size_t size = getpagesize();
int protFlags[] = { PROT_READ, PROT_WRITE };
for (size_t i = 0; i < arraysize(protFlags); i++) {
@@ -238,9 +244,9 @@
}
TEST(AshmemTest, ForkMultiRegionTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
constexpr int nRegions = 16;
unique_fd fd[nRegions];
@@ -248,8 +254,8 @@
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd[i], PROT_READ | PROT_WRITE));
void* region = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
- memcpy(region, &data, size);
- ASSERT_EQ(0, memcmp(region, &data, size));
+ memcpy(region, data.data(), size);
+ ASSERT_EQ(0, memcmp(region, data.data(), size));
EXPECT_EQ(0, munmap(region, size));
}
@@ -262,7 +268,7 @@
if (region == MAP_FAILED) {
_exit(1);
}
- if (memcmp(region, &data, size) != 0) {
+ if (memcmp(region, data.data(), size) != 0) {
munmap(region, size);
_exit(2);
}
@@ -272,11 +278,11 @@
_exit(0);
}, ::testing::ExitedWithCode(0), "");
- memset(&data, 0, size);
+ memset(data.data(), 0, size);
for (int i = 0; i < nRegions; i++) {
void *region;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
- ASSERT_EQ(0, memcmp(region, &data, size));
+ ASSERT_EQ(0, memcmp(region, data.data(), size));
EXPECT_EQ(0, munmap(region, size));
}
}
diff --git a/libutils/include/utils/CallStack.h b/libutils/include/utils/CallStack.h
index fe4d4f5..54d559b 100644
--- a/libutils/include/utils/CallStack.h
+++ b/libutils/include/utils/CallStack.h
@@ -37,7 +37,9 @@
# endif // !WEAKS_AVAILABLE
#endif // CALLSTACK_WEAK predefined
-#define ALWAYS_INLINE __attribute__((always_inline))
+#ifndef CALLSTACK_ALWAYS_INLINE
+#define CALLSTACK_ALWAYS_INLINE __attribute__((always_inline))
+#endif // CALLSTACK_ALWAYS_INLINE predefined
namespace android {
@@ -102,7 +104,7 @@
// Return current call stack if possible, nullptr otherwise.
#ifdef WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
+ static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
if (reinterpret_cast<uintptr_t>(getCurrentInternal) == 0) {
ALOGW("CallStack::getCurrentInternal not linked, returning null");
return CallStackUPtr(nullptr);
@@ -111,14 +113,15 @@
}
}
#else // !WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t = 1) {
+ static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t = 1) {
return CallStackUPtr(nullptr);
}
#endif // !WEAKS_AVAILABLE
#ifdef WEAKS_AVAILABLE
- static void ALWAYS_INLINE logStack(const char* logtag, CallStack* stack = getCurrent().get(),
- android_LogPriority priority = ANDROID_LOG_DEBUG) {
+ static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+ CallStack* stack = getCurrent().get(),
+ android_LogPriority priority = ANDROID_LOG_DEBUG) {
if (reinterpret_cast<uintptr_t>(logStackInternal) != 0 && stack != nullptr) {
logStackInternal(logtag, stack, priority);
} else {
@@ -127,15 +130,16 @@
}
#else
- static void ALWAYS_INLINE logStack(const char* logtag, CallStack* = getCurrent().get(),
- android_LogPriority = ANDROID_LOG_DEBUG) {
+ static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+ CallStack* = getCurrent().get(),
+ android_LogPriority = ANDROID_LOG_DEBUG) {
ALOG(LOG_WARN, logtag, "CallStack::logStackInternal not linked");
}
#endif // !WEAKS_AVAILABLE
#ifdef WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* stack = getCurrent().get()) {
+ static String8 CALLSTACK_ALWAYS_INLINE
+ stackToString(const char* prefix = nullptr, const CallStack* stack = getCurrent().get()) {
if (reinterpret_cast<uintptr_t>(stackToStringInternal) != 0 && stack != nullptr) {
return stackToStringInternal(prefix, stack);
} else {
@@ -143,8 +147,8 @@
}
}
#else // !WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* = getCurrent().get()) {
+ static String8 CALLSTACK_ALWAYS_INLINE stackToString(const char* prefix = nullptr,
+ const CallStack* = getCurrent().get()) {
return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
}
#endif // !WEAKS_AVAILABLE
@@ -165,4 +169,6 @@
} // namespace android
+#undef CALLSTACK_ALWAYS_INLINE
+
#endif // ANDROID_CALLSTACK_H
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
index ba1a6b8..d365075 100644
--- a/libvendorsupport/include/vendorsupport/api_level.h
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -14,38 +14,34 @@
#pragma once
-#include <android/api-level.h>
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
#define __ANDROID_VENDOR_API_MAX__ 1000000
#define __INVALID_API_LEVEL -1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/**
* @brief Find corresponding vendor API level from an SDK API version.
*
* @details
* SDK API versions and vendor API levels are not compatible and not
- * convertible. However, this function can be used to compare the two versions
+ * exchangeable. However, this function can be used to compare the two versions
* to know which one is newer than the other.
*
- * @param sdk_api_level The SDK version int. This must be less than 10000.
+ * @param sdkApiLevel The SDK version int. This must be less than 10000.
* @return The corresponding vendor API level of the SDK version. -1 if the SDK
* version is invalid or 10000.
*/
-int vendor_api_level_of(int sdk_api_level);
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel);
/**
* @brief Find corresponding SDK API version from a vendor API level.
*
- * @param vendor_api_level The vendor API level int.
+ * @param vendorApiLevel The vendor API level int.
* @return The corresponding SDK API version of the vendor API level. -1 if the
* vendor API level is invalid.
*/
-int sdk_api_level_of(int vendor_api_level);
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel);
-#ifdef __cplusplus
-}
-#endif
+__END_DECLS
diff --git a/libvendorsupport/libvendorsupport.map.txt b/libvendorsupport/libvendorsupport.map.txt
index 9a23b94..d99c834 100644
--- a/libvendorsupport/libvendorsupport.map.txt
+++ b/libvendorsupport/libvendorsupport.map.txt
@@ -1,7 +1,7 @@
LIBVENDORSUPPORT {
global:
- vendor_api_level_of; # llndk systemapi
- sdk_api_level_of; # llndk systemapi
+ AVendorSupport_getVendorApiLevelOf; # llndk systemapi
+ AVendorSupport_getSdkApiLevelOf; # llndk systemapi
local:
*;
};
diff --git a/libvendorsupport/tests/version_props_test.cpp b/libvendorsupport/tests/version_props_test.cpp
index 538a2e2..ad54c88 100644
--- a/libvendorsupport/tests/version_props_test.cpp
+++ b/libvendorsupport/tests/version_props_test.cpp
@@ -21,17 +21,17 @@
namespace {
-TEST(vendorsupport, get_corresponding_vendor_api_level) {
- ASSERT_EQ(__ANDROID_API_U__, vendor_api_level_of(__ANDROID_API_U__));
- ASSERT_EQ(202404, vendor_api_level_of(__ANDROID_API_V__));
- ASSERT_EQ(__INVALID_API_LEVEL, vendor_api_level_of(__ANDROID_API_FUTURE__));
+TEST(VendorSupport, GetCorrespondingVendorApiLevel) {
+ ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_U__));
+ ASSERT_EQ(202404, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_V__));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_FUTURE__));
}
-TEST(vendorsupport, get_corresponding_sdk_api_level) {
- ASSERT_EQ(__ANDROID_API_U__, sdk_api_level_of(__ANDROID_API_U__));
- ASSERT_EQ(__ANDROID_API_V__, sdk_api_level_of(202404));
- ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(__ANDROID_VENDOR_API_MAX__));
- ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(35));
+TEST(VendorSupport, GetCorrespondingSdkApiLevel) {
+ ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getSdkApiLevelOf(__ANDROID_API_U__));
+ ASSERT_EQ(__ANDROID_API_V__, AVendorSupport_getSdkApiLevelOf(202404));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(__ANDROID_VENDOR_API_MAX__));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(35));
}
} // namespace
\ No newline at end of file
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.c
index 4d0e45e..835828c 100644
--- a/libvendorsupport/version_props.c
+++ b/libvendorsupport/version_props.c
@@ -16,26 +16,26 @@
#include <log/log.h>
-int vendor_api_level_of(int sdk_api_level) {
- if (sdk_api_level < __ANDROID_API_V__) {
- return sdk_api_level;
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel) {
+ if (sdkApiLevel < __ANDROID_API_V__) {
+ return sdkApiLevel;
}
// In Android V, vendor API level started with version 202404.
// The calculation assumes that the SDK api level bumps once a year.
- if (sdk_api_level < __ANDROID_API_FUTURE__) {
- return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+ if (sdkApiLevel < __ANDROID_API_FUTURE__) {
+ return 202404 + ((sdkApiLevel - __ANDROID_API_V__) * 100);
}
- ALOGE("The SDK version must be less than 10000: %d", sdk_api_level);
+ ALOGE("The SDK version must be less than 10000: %d", sdkApiLevel);
return __INVALID_API_LEVEL;
}
-int sdk_api_level_of(int vendor_api_level) {
- if (vendor_api_level < __ANDROID_API_V__) {
- return vendor_api_level;
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel) {
+ if (vendorApiLevel < __ANDROID_API_V__) {
+ return vendorApiLevel;
}
- if (vendor_api_level >= 202404 && vendor_api_level < __ANDROID_VENDOR_API_MAX__) {
- return (vendor_api_level - 202404) / 100 + __ANDROID_API_V__;
+ if (vendorApiLevel >= 202404 && vendorApiLevel < __ANDROID_VENDOR_API_MAX__) {
+ return (vendorApiLevel - 202404) / 100 + __ANDROID_API_V__;
}
- ALOGE("Unexpected vendor api level: %d", vendor_api_level);
+ ALOGE("Unexpected vendor api level: %d", vendorApiLevel);
return __INVALID_API_LEVEL;
}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0646d14..f3b2d03 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -640,6 +640,11 @@
restorecon_recursive /metadata/apex
mkdir /metadata/staged-install 0770 root system
+
+ mkdir /metadata/aconfig 0750 root system
+ mkdir /metadata/aconfig/flags 0750 root system
+ mkdir /metadata/aconfig/boot 0754 root system
+
on late-fs
# Ensure that tracefs has the correct permissions.
# This does not work correctly if it is called in post-fs.
diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index 66d0876..b29628e 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -91,9 +91,12 @@
* struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
* requests
* @app_id_len: length of app ID that follows this structure
+ * @crash_reason: architecture-specific code representing the reason for the
+ * crash
*/
struct metrics_report_crash_req {
uint32_t app_id_len;
+ uint32_t crash_reason;
} __attribute__((__packed__));
#define METRICS_MAX_APP_ID_LEN 256
diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index 5aa4392..b21eca6 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -35,7 +35,6 @@
LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
endif
-# TODO(b/306364873): move this to be flag-controlled?
ifeq ($(SECRETKEEPER_ENABLED),true)
LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty
else