Merge "dmctl: add report of IMA" into main
diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 7d20995..235fdfd 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -21,8 +21,11 @@
local_include_dirs: ["include"],
product_variables: {
debuggable: {
- cflags: ["-UANDROID_DEBUGGABLE", "-DANDROID_DEBUGGABLE=1"],
- }
+ cflags: [
+ "-UANDROID_DEBUGGABLE",
+ "-DANDROID_DEBUGGABLE=1",
+ ],
+ },
},
}
@@ -256,7 +259,7 @@
],
static_libs: [
- "libdexfile_support", // libunwindstack dependency
+ "libdexfile_support", // libunwindstack dependency
"libunwindstack",
"liblzma",
"libbase",
@@ -299,7 +302,7 @@
},
android: {
runtime_libs: [
- "libdexfile", // libdexfile_support dependency
+ "libdexfile", // libdexfile_support dependency
],
},
},
@@ -368,6 +371,11 @@
},
},
+ sanitize: {
+ memtag_heap: true,
+ memtag_stack: true,
+ },
+
shared_libs: [
"libbase",
"libcutils",
@@ -494,7 +502,7 @@
header_libs: [
"bionic_libc_platform_headers",
- "libdebuggerd_common_headers"
+ "libdebuggerd_common_headers",
],
static_libs: [
@@ -552,7 +560,6 @@
},
}
-
// This installs the "other" architecture (so 32-bit on 64-bit device).
prebuilt_etc {
name: "crash_dump.policy_other",
diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 8633cb8..61d7155 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -14,5 +14,10 @@
{
"name": "debuggerd_test"
}
+ ],
+ "postsubmit": [
+ {
+ "name": "CtsCrashDetailHostTestCases"
+ }
]
}
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/crasher/Android.bp b/debuggerd/crasher/Android.bp
index fe1689c..4c6a400 100644
--- a/debuggerd/crasher/Android.bp
+++ b/debuggerd/crasher/Android.bp
@@ -15,7 +15,7 @@
"-fstack-protector-all",
"-Wno-date-time",
],
- tidy: false, // crasher.cpp tests many memory access errors
+ tidy: false, // crasher.cpp tests many memory access errors
srcs: ["crasher.cpp"],
arch: {
arm: {
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index c0522aa..526e2ca 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -21,6 +21,7 @@
#include <linux/prctl.h>
#include <malloc.h>
#include <pthread.h>
+#include <setjmp.h>
#include <stdlib.h>
#include <sys/capability.h>
#include <sys/mman.h>
@@ -37,6 +38,7 @@
#include <string>
#include <thread>
+#include <android/crash_detail.h>
#include <android/dlext.h>
#include <android/fdsan.h>
#include <android/set_abort_message.h>
@@ -600,6 +602,54 @@
#endif
}
+__attribute__((noinline)) void mte_illegal_setjmp_helper(jmp_buf& jump_buf) {
+ // This frame is at least 8 bytes for storing and restoring the LR before the
+ // setjmp below. So this can never get an empty stack frame, even if we omit
+ // the frame pointer. So, the SP of this is always less (numerically) than the
+ // calling function frame.
+ setjmp(jump_buf);
+}
+
+TEST_F(CrasherTest, mte_illegal_setjmp) {
+ // This setjmp is illegal because it jumps back into a function that already returned.
+ // Quoting man 3 setjmp:
+ // If the function which called setjmp() returns before longjmp() is
+ // called, the behavior is undefined. Some kind of subtle or
+ // unsubtle chaos is sure to result.
+ // https://man7.org/linux/man-pages/man3/longjmp.3.html
+#if defined(__aarch64__)
+ if (!mte_supported()) {
+ GTEST_SKIP() << "Requires MTE";
+ }
+
+ int intercept_result;
+ unique_fd output_fd;
+ StartProcess([&]() {
+ SetTagCheckingLevelSync();
+ jmp_buf jump_buf;
+ mte_illegal_setjmp_helper(jump_buf);
+ longjmp(jump_buf, 1);
+ });
+
+ 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);
+
+ // In our test-case, we have a NEGATIVE stack adjustment, which is being
+ // interpreted as unsigned integer, and thus is "too large".
+ // TODO(fmayer): fix the error message for this
+ ASSERT_MATCH(result, R"(memtag_handle_longjmp: stack adjustment too large)");
+#else
+ GTEST_SKIP() << "Requires aarch64";
+#endif
+}
+
TEST_F(CrasherTest, mte_async) {
#if defined(__aarch64__)
if (!mte_supported()) {
@@ -939,6 +989,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;
@@ -2419,7 +2696,7 @@
match_str += format_full_pointer(crash_uptr);
ASSERT_MATCH(result, match_str);
- ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+ ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
// Verifies that the fault address error message is at the end of the
// maps section. To do this, the check below looks for the start of the
@@ -2471,7 +2748,7 @@
match_str += format_full_pointer(reinterpret_cast<uintptr_t>(middle_ptr));
ASSERT_MATCH(result, match_str);
- ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+ ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
match_str = android::base::StringPrintf(
R"( %s.*\n--->Fault address falls at %s between mapped regions\n %s)",
@@ -2509,7 +2786,7 @@
match_str += format_full_pointer(reinterpret_cast<uintptr_t>(ptr));
ASSERT_MATCH(result, match_str);
- ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+ ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
match_str = android::base::StringPrintf(R"(\n--->%s.*\n)", format_pointer(ptr).c_str());
ASSERT_MATCH(result, match_str);
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/Android.bp b/debuggerd/proto/Android.bp
index 7be5d61..7b9e780 100644
--- a/debuggerd/proto/Android.bp
+++ b/debuggerd/proto/Android.bp
@@ -52,4 +52,3 @@
sdk_version: "current",
static_libs: ["libprotobuf-java-lite"],
}
-
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/rust/tombstoned_client/Android.bp b/debuggerd/rust/tombstoned_client/Android.bp
index 2007f39..bf19bb7 100644
--- a/debuggerd/rust/tombstoned_client/Android.bp
+++ b/debuggerd/rust/tombstoned_client/Android.bp
@@ -8,7 +8,7 @@
"wrapper.cpp",
],
generated_sources: [
- "libtombstoned_client_rust_bridge_code"
+ "libtombstoned_client_rust_bridge_code",
],
header_libs: [
"libbase_headers",
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/debuggerd/seccomp_policy/crash_dump.policy.def b/debuggerd/seccomp_policy/crash_dump.policy.def
index 972a575..dc751da 100644
--- a/debuggerd/seccomp_policy/crash_dump.policy.def
+++ b/debuggerd/seccomp_policy/crash_dump.policy.def
@@ -25,8 +25,8 @@
faccessat: 1
recvmsg: 1
recvfrom: 1
-sysinfo: 1
setsockopt: 1
+sysinfo: 1
process_vm_readv: 1
@@ -53,20 +53,29 @@
#if 0
libminijail on vendor partitions older than P does not have constants from <sys/mman.h>.
-Define the values of PROT_READ and PROT_WRITE ourselves to maintain backwards compatibility.
+Define values for PROT_READ, PROT_WRITE and PROT_MTE ourselves to maintain backwards compatibility.
#else
#define PROT_READ 0x1
#define PROT_WRITE 0x2
+#define PROT_MTE 0x20
#endif
madvise: 1
+#if defined(__aarch64__)
+mprotect: arg2 in PROT_READ|PROT_WRITE|PROT_MTE
+#else
mprotect: arg2 in PROT_READ|PROT_WRITE
+#endif
munmap: 1
#if defined(__LP64__)
getuid: 1
fstat: 1
+#if defined(__aarch64__)
+mmap: arg2 in PROT_READ|PROT_WRITE|PROT_MTE
+#else
mmap: arg2 in PROT_READ|PROT_WRITE
+#endif
#else
getuid32: 1
fstat64: 1
diff --git a/debuggerd/test_permissive_mte/Android.bp b/debuggerd/test_permissive_mte/Android.bp
index d3f7520..0ad3243 100644
--- a/debuggerd/test_permissive_mte/Android.bp
+++ b/debuggerd/test_permissive_mte/Android.bp
@@ -17,22 +17,28 @@
}
cc_binary {
- name: "mte_crash",
- tidy: false,
- srcs: ["mte_crash.cpp"],
- sanitize: {
- memtag_heap: true,
- diag: {
- memtag_heap: true,
+ name: "mte_crash",
+ tidy: false,
+ srcs: ["mte_crash.cpp"],
+ sanitize: {
+ memtag_heap: true,
+ diag: {
+ memtag_heap: true,
+ },
},
- },
}
java_test_host {
name: "permissive_mte_test",
libs: ["tradefed"],
- static_libs: ["frameworks-base-hostutils", "cts-install-lib-host"],
- srcs: ["src/**/PermissiveMteTest.java", ":libtombstone_proto-src"],
+ static_libs: [
+ "frameworks-base-hostutils",
+ "cts-install-lib-host",
+ ],
+ srcs: [
+ "src/**/PermissiveMteTest.java",
+ ":libtombstone_proto-src",
+ ],
data: [":mte_crash"],
test_config: "AndroidTest.xml",
test_suites: ["general-tests"],
diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index cf7904f..e2a67a2 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -61,7 +61,6 @@
struct CrashArtifact {
unique_fd fd;
- std::optional<std::string> temporary_path;
static CrashArtifact devnull() {
CrashArtifact result;
@@ -145,16 +144,13 @@
std::optional<std::string> path;
result.fd.reset(openat(dir_fd_, ".", O_WRONLY | O_APPEND | O_TMPFILE | O_CLOEXEC, 0660));
if (result.fd == -1) {
- // We might not have O_TMPFILE. Try creating with an arbitrary filename instead.
- static size_t counter = 0;
- std::string tmp_filename = StringPrintf(".temporary%zu", counter++);
- result.fd.reset(openat(dir_fd_, tmp_filename.c_str(),
- O_WRONLY | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC, 0660));
- if (result.fd == -1) {
- PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
- }
+ PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
+ }
- result.temporary_path = std::move(tmp_filename);
+ // We need to fchmodat after creating to avoid getting the umask applied.
+ std::string fd_path = StringPrintf("/proc/self/fd/%d", result.fd.get());
+ if (fchmodat(dir_fd_, fd_path.c_str(), 0664, 0) != 0) {
+ PLOG(ERROR) << "Failed to make tombstone world-readable";
}
return std::move(result);
@@ -417,6 +413,7 @@
return false;
}
+ // This fd is created inside of dirfd in CrashQueue::create_temporary_file.
std::string fd_path = StringPrintf("/proc/self/fd/%d", fd.get());
rc = linkat(AT_FDCWD, fd_path.c_str(), dirfd.get(), path.c_str(), AT_SYMLINK_FOLLOW);
if (rc != 0) {
@@ -471,20 +468,6 @@
rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
}
}
-
- // If we don't have O_TMPFILE, we need to clean up after ourselves.
- if (crash->output.text.temporary_path) {
- rc = unlinkat(queue->dir_fd().get(), crash->output.text.temporary_path->c_str(), 0);
- if (rc != 0) {
- PLOG(ERROR) << "failed to unlink temporary tombstone at " << paths.text;
- }
- }
- if (crash->output.proto && crash->output.proto->temporary_path) {
- rc = unlinkat(queue->dir_fd().get(), crash->output.proto->temporary_path->c_str(), 0);
- if (rc != 0) {
- PLOG(ERROR) << "failed to unlink temporary proto tombstone";
- }
- }
}
static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {
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/libdm/dm_target.cpp b/fs_mgr/libdm/dm_target.cpp
index 90d91a0..1f6bd1a 100644
--- a/fs_mgr/libdm/dm_target.cpp
+++ b/fs_mgr/libdm/dm_target.cpp
@@ -61,6 +61,10 @@
return block_device_ + " " + std::to_string(physical_sector_);
}
+std::string DmTargetStripe::GetParameterString() const {
+ return "2 " + std::to_string(chunksize) + " " + block_device0_ + " 0 " + block_device1_ + " 0";
+}
+
DmTargetVerity::DmTargetVerity(uint64_t start, uint64_t length, uint32_t version,
const std::string& block_device, const std::string& hash_device,
uint32_t data_block_size, uint32_t hash_block_size,
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index a0129c2..d043be6 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -181,6 +181,13 @@
ASSERT_EQ(dm.GetState(dev.name()), DmDeviceState::ACTIVE);
}
+TEST_F(DmTest, StripeArgs) {
+ DmTargetStripe target(0, 4096, 1024, "/dev/loop0", "/dev/loop1");
+ ASSERT_EQ(target.name(), "striped");
+ ASSERT_TRUE(target.Valid());
+ ASSERT_EQ(target.GetParameterString(), "2 1024 /dev/loop0 0 /dev/loop1 0");
+}
+
TEST_F(DmTest, DmVerityArgsAvb2) {
std::string device = "/dev/block/platform/soc/1da4000.ufshc/by-name/vendor_a";
std::string algorithm = "sha1";
diff --git a/fs_mgr/libdm/include/libdm/dm_target.h b/fs_mgr/libdm/include/libdm/dm_target.h
index 09fe200..97f3c13 100644
--- a/fs_mgr/libdm/include/libdm/dm_target.h
+++ b/fs_mgr/libdm/include/libdm/dm_target.h
@@ -116,6 +116,24 @@
uint64_t physical_sector_;
};
+class DmTargetStripe final : public DmTarget {
+ public:
+ DmTargetStripe(uint64_t start, uint64_t length, uint64_t chunksize,
+ const std::string& block_device0, const std::string& block_device1)
+ : DmTarget(start, length),
+ chunksize(chunksize),
+ block_device0_(block_device0),
+ block_device1_(block_device1) {}
+
+ std::string name() const override { return "striped"; }
+ std::string GetParameterString() const override;
+
+ private:
+ uint64_t chunksize;
+ std::string block_device0_;
+ std::string block_device1_;
+};
+
class DmTargetVerity final : public DmTarget {
public:
DmTargetVerity(uint64_t start, uint64_t length, uint32_t version,
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/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 3c5b394..2021348 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -109,6 +109,40 @@
ASSERT_EQ(reader.header_v3().op_count, 20);
}
+TEST_F(CowTestV3, MaxOpSingleThreadCompression) {
+ CowOptions options;
+ options.op_count_max = 20;
+ options.num_compress_threads = 1;
+ options.compression_factor = 4096 * 8;
+ options.compression = "lz4";
+
+ auto writer = CreateCowWriter(3, options, GetCowFd());
+ ASSERT_TRUE(writer->AddZeroBlocks(1, 20));
+ std::string data = "This is some data, believe it";
+ data.resize(options.block_size, '\0');
+
+ ASSERT_FALSE(writer->AddRawBlocks(5, data.data(), data.size()));
+
+ ASSERT_TRUE(writer->Finalize());
+}
+
+TEST_F(CowTestV3, MaxOpMultiThreadCompression) {
+ CowOptions options;
+ options.op_count_max = 20;
+ options.num_compress_threads = 2;
+ options.compression_factor = 4096 * 8;
+ options.compression = "lz4";
+
+ auto writer = CreateCowWriter(3, options, GetCowFd());
+ ASSERT_TRUE(writer->AddZeroBlocks(1, 20));
+ std::string data = "This is some data, believe it";
+ data.resize(options.block_size, '\0');
+
+ ASSERT_FALSE(writer->AddRawBlocks(5, data.data(), data.size()));
+
+ ASSERT_TRUE(writer->Finalize());
+}
+
TEST_F(CowTestV3, ZeroOp) {
CowOptions options;
options.op_count_max = 20;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 22e6f2c..de2e528 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -121,7 +121,6 @@
return false;
}
- LOG(INFO) << "Compression factor: " << header_.max_compression_size;
num_compress_threads_ = std::max(int(options_.num_compress_threads), 1);
auto parts = android::base::Split(options_.compression, ",");
if (parts.size() > 2) {
@@ -356,6 +355,9 @@
<< ", actual number of blocks received from compressor " << blocks.size();
return false;
}
+ if (!CheckOpCount(blocks.size())) {
+ return false;
+ }
size_t blocks_written = 0;
for (size_t blk_index = 0; blk_index < blocks.size(); blk_index++) {
CowOperation& op = cached_ops_.emplace_back();
@@ -395,9 +397,6 @@
}
const auto bytes = reinterpret_cast<const uint8_t*>(data);
const size_t num_blocks = (size / header_.block_size);
- if (!CheckOpCount(num_blocks)) {
- return false;
- }
for (size_t i = 0; i < num_blocks;) {
const size_t blocks_to_write =
std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);
@@ -604,41 +603,47 @@
std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithThreadedCompression(
const size_t num_blocks, const void* data, CowOperationType type) {
const size_t num_threads = num_compress_threads_;
- const size_t blocks_per_thread = DivRoundUp(num_blocks, num_threads);
const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
+ // We will alternate which thread to send compress work to. E.g. alternate between T1 and T2
+ // until all blocks are processed
std::vector<CompressedBuffer> compressed_vec;
- // Submit the blocks per thread. The retrieval of
- // compressed buffers has to be done in the same order.
- // We should not poll for completed buffers in a different order as the
- // buffers are tightly coupled with block ordering.
- for (size_t i = 0; i < num_threads; i++) {
- CompressWorker* worker = compress_threads_[i].get();
- auto blocks_in_batch = std::min(num_blocks - i * blocks_per_thread, blocks_per_thread);
- // Enqueue the blocks to be compressed for each thread.
- while (blocks_in_batch) {
- CompressedBuffer buffer;
+ int iteration = 0;
+ int blocks_to_compress = static_cast<int>(num_blocks);
+ while (blocks_to_compress) {
+ CompressedBuffer buffer;
+ CompressWorker* worker = compress_threads_[iteration % num_threads].get();
- const size_t compression_factor = GetCompressionFactor(blocks_in_batch, type);
- size_t num_blocks = compression_factor / header_.block_size;
+ const size_t compression_factor = GetCompressionFactor(blocks_to_compress, type);
+ size_t num_blocks = compression_factor / header_.block_size;
- buffer.compression_factor = compression_factor;
- worker->EnqueueCompressBlocks(iter, compression_factor, 1);
- compressed_vec.push_back(std::move(buffer));
- blocks_in_batch -= num_blocks;
- iter += compression_factor;
- }
+ worker->EnqueueCompressBlocks(iter, compression_factor, 1);
+ buffer.compression_factor = compression_factor;
+ compressed_vec.push_back(std::move(buffer));
+
+ iteration++;
+ iter += compression_factor;
+ blocks_to_compress -= num_blocks;
}
- // Fetch compressed buffers from the threads
std::vector<std::vector<uint8_t>> compressed_buf;
+ std::vector<std::vector<std::vector<uint8_t>>> worker_buffers(num_threads);
compressed_buf.clear();
for (size_t i = 0; i < num_threads; i++) {
CompressWorker* worker = compress_threads_[i].get();
- if (!worker->GetCompressedBuffers(&compressed_buf)) {
+ if (!worker->GetCompressedBuffers(&worker_buffers[i])) {
return {};
}
}
+ // compressed_vec | CB 1 | CB 2 | CB 3 | CB 4 | <-compressed buffers
+ // t1 t2 t1 t2 <- processed by these threads
+ // Ordering is important here. We need to retrieve the compressed data in the same order we
+ // processed it and assume that that we submit data beginning with the first thread and then
+ // round robin the consecutive data calls. We need to Fetch compressed buffers from the threads
+ // via the same ordering
+ for (size_t i = 0; i < compressed_vec.size(); i++) {
+ compressed_buf.emplace_back(worker_buffers[i % num_threads][i / num_threads]);
+ }
if (compressed_vec.size() != compressed_buf.size()) {
LOG(ERROR) << "Compressed buffer size: " << compressed_buf.size()
diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index cf26a16..a4a2c1a 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -39,6 +39,7 @@
namespace android {
namespace snapshot {
+// @VsrTest = 3.7.6
class PartitionCowCreatorTest : public ::testing::Test {
public:
void SetUp() override {
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index ba5fb88..e6c4de6 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -508,8 +508,6 @@
// When snapshots are on current slot, we determine the size
// of block device based on the number of COW operations. We cannot
// use base device as it will be from older image.
- size_t num_ops = 0;
- uint64_t dev_sz = 0;
unique_fd fd(open(cow_file.c_str(), O_RDONLY | O_CLOEXEC));
if (fd < 0) {
PLOG(ERROR) << "Failed to open " << cow_file;
@@ -522,13 +520,18 @@
return false;
}
+ uint64_t dev_sz = 0;
const auto& header = reader.GetHeader();
- if (header.prefix.major_version > 2) {
- LOG(ERROR) << "COW format not supported";
- return false;
+ if (header.prefix.major_version == 2) {
+ const size_t num_ops = reader.get_num_total_data_ops();
+ dev_sz = (num_ops * header.block_size);
+ } else {
+ // create_snapshot will skip in-place copy ops. Hence, fetch this
+ // information directly from v3 header.
+ const auto& v3_header = reader.header_v3();
+ dev_sz = v3_header.op_count_max * v3_header.block_size;
}
- num_ops = reader.get_num_total_data_ops();
- dev_sz = (num_ops * header.block_size);
+
base_sectors = dev_sz >> 9;
} else {
// For userspace snapshots, the size of the base device is taken as the
@@ -3242,6 +3245,8 @@
// Older OTAs don't set an explicit compression type, so default to gz.
compression_algorithm = "gz";
}
+ LOG(INFO) << "using compression algorithm: " << compression_algorithm
+ << ", max compressible block size: " << compression_factor;
}
PartitionCowCreator cow_creator{
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e538d50..47e6ce9 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -104,6 +104,7 @@
void MountMetadata();
+// @VsrTest = 3.7.6
class SnapshotTest : public ::testing::Test {
public:
SnapshotTest() : dm_(DeviceMapper::Instance()) {}
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 0396a55..5d3f96c 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -15,6 +15,7 @@
//
#include <sysexits.h>
+#include <unistd.h>
#include <chrono>
#include <filesystem>
@@ -46,13 +47,14 @@
#include "partition_cow_creator.h"
-#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
#include <BootControlClient.h>
-#endif
using namespace std::chrono_literals;
using namespace std::string_literals;
using namespace android::storage_literals;
+using android::base::LogdLogger;
+using android::base::StderrLogger;
+using android::base::TeeLogger;
using android::fs_mgr::CreateLogicalPartitionParams;
using android::fs_mgr::FindPartition;
using android::fs_mgr::GetPartitionSize;
@@ -79,7 +81,11 @@
" revert-snapshots\n"
" Prepares devices to boot without snapshots on next boot.\n"
" This does not delete the snapshot. It only removes the indicators\n"
- " so that first stage init will not mount from snapshots.\n";
+ " so that first stage init will not mount from snapshots.\n"
+ " apply-update\n"
+ " Apply the incremental OTA update wherein the snapshots are\n"
+ " directly written to COW block device. This will bypass update-engine\n"
+ " and the device will be ready to boot from the target build.\n";
return EX_USAGE;
}
@@ -96,14 +102,22 @@
bool DeleteSnapshots();
bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
bool BeginUpdate();
+ bool ApplyUpdate();
private:
std::optional<std::string> GetCowImagePath(std::string& name);
+ bool PrepareUpdate();
bool WriteSnapshotPatch(std::string cow_device, std::string patch);
+ std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
+ const std::string& partiton_name);
std::unique_ptr<SnapshotManager::LockedFile> lock_;
std::unique_ptr<SnapshotManager> sm_;
std::vector<std::future<bool>> threads_;
std::string snapshot_dir_path_;
+ std::unordered_map<std::string, chromeos_update_engine::DynamicPartitionGroup*> group_map_;
+
+ std::vector<std::string> patchfiles_;
+ chromeos_update_engine::DeltaArchiveManifest manifest_;
};
MapSnapshots::MapSnapshots(std::string path) {
@@ -115,6 +129,178 @@
snapshot_dir_path_ = path + "/";
}
+std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
+ const std::string& partition_name) {
+ std::string group_name;
+ for (const auto& partition : pt.partitions) {
+ std::string name = android::fs_mgr::GetPartitionName(partition);
+ auto suffix = android::fs_mgr::GetPartitionSlotSuffix(name);
+ std::string pname = name.substr(0, name.size() - suffix.size());
+ if (pname == partition_name) {
+ std::string group_name =
+ android::fs_mgr::GetPartitionGroupName(pt.groups[partition.group_index]);
+ return group_name.substr(0, group_name.size() - suffix.size());
+ }
+ }
+ return "";
+}
+
+bool MapSnapshots::PrepareUpdate() {
+ auto source_slot = fs_mgr_get_slot_suffix();
+ auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
+ auto super_source = fs_mgr_get_super_partition_name(source_slot_number);
+
+ // Get current partition information.
+ PartitionOpener opener;
+ auto source_metadata = ReadMetadata(opener, super_source, source_slot_number);
+ if (!source_metadata) {
+ LOG(ERROR) << "Could not read source partition metadata.\n";
+ return false;
+ }
+
+ auto dap = manifest_.mutable_dynamic_partition_metadata();
+ dap->set_snapshot_enabled(true);
+ dap->set_vabc_enabled(true);
+ dap->set_vabc_compression_param("lz4");
+ dap->set_cow_version(3);
+
+ for (const auto& entry : std::filesystem::directory_iterator(snapshot_dir_path_)) {
+ if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
+ patchfiles_.push_back(android::base::Basename(entry.path().generic_string()));
+ }
+ }
+
+ for (auto& patchfile : patchfiles_) {
+ std::string parsing_file = snapshot_dir_path_ + patchfile;
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file.c_str(), O_RDONLY)));
+ if (fd < 0) {
+ LOG(ERROR) << "Failed to open file: " << parsing_file;
+ return false;
+ }
+ uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+ if (!dev_sz) {
+ LOG(ERROR) << "Could not determine block device size: " << parsing_file;
+ return false;
+ }
+
+ const int block_sz = 4_KiB;
+ dev_sz += block_sz - 1;
+ dev_sz &= ~(block_sz - 1);
+
+ auto npos = patchfile.rfind(".patch");
+ auto partition_name = patchfile.substr(0, npos);
+
+ chromeos_update_engine::DynamicPartitionGroup* group = nullptr;
+ std::string group_name = GetGroupName(*source_metadata.get(), partition_name);
+ if (group_map_.find(group_name) != group_map_.end()) {
+ group = group_map_[group_name];
+ } else {
+ group = dap->add_groups();
+ group->set_name(group_name);
+ group_map_[group_name] = group;
+ }
+ group->add_partition_names(partition_name);
+
+ auto pu = manifest_.mutable_partitions()->Add();
+ pu->set_partition_name(partition_name);
+ pu->set_estimate_cow_size(dev_sz);
+
+ CowReader reader;
+ if (!reader.Parse(fd)) {
+ LOG(ERROR) << "COW reader parse failed";
+ return false;
+ }
+
+ uint64_t new_device_size = 0;
+ const auto& header = reader.GetHeader();
+ if (header.prefix.major_version == 2) {
+ size_t num_ops = reader.get_num_total_data_ops();
+ new_device_size = (num_ops * header.block_size);
+ } else {
+ const auto& v3_header = reader.header_v3();
+ new_device_size = v3_header.op_count_max * v3_header.block_size;
+ }
+
+ LOG(INFO) << "Partition: " << partition_name << " Group_name: " << group_name
+ << " size: " << new_device_size << " COW-size: " << dev_sz;
+ pu->mutable_new_partition_info()->set_size(new_device_size);
+ }
+ return true;
+}
+
+bool MapSnapshots::ApplyUpdate() {
+ if (!PrepareUpdate()) {
+ LOG(ERROR) << "PrepareUpdate failed";
+ return false;
+ }
+ if (!sm_->BeginUpdate()) {
+ LOG(ERROR) << "BeginUpdate failed";
+ return false;
+ }
+ if (!sm_->CreateUpdateSnapshots(manifest_)) {
+ LOG(ERROR) << "Could not apply snapshots";
+ return false;
+ }
+
+ LOG(INFO) << "CreateUpdateSnapshots success";
+ if (!sm_->MapAllSnapshots(10s)) {
+ LOG(ERROR) << "MapAllSnapshots failed";
+ return false;
+ }
+
+ LOG(INFO) << "MapAllSnapshots success";
+
+ auto& dm = android::dm::DeviceMapper::Instance();
+ auto target_slot = fs_mgr_get_other_slot_suffix();
+ for (auto& patchfile : patchfiles_) {
+ auto npos = patchfile.rfind(".patch");
+ auto partition_name = patchfile.substr(0, npos) + target_slot;
+ auto cow_device = partition_name + "-cow";
+ std::string cow_path;
+ if (!dm.GetDmDevicePathByName(cow_device, &cow_path)) {
+ LOG(ERROR) << "Failed to cow path";
+ return false;
+ }
+ threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,
+ this, cow_path, patchfile));
+ }
+
+ bool ret = true;
+ for (auto& t : threads_) {
+ ret = t.get() && ret;
+ }
+ if (!ret) {
+ LOG(ERROR) << "Snapshot writes failed";
+ return false;
+ }
+ if (!sm_->UnmapAllSnapshots()) {
+ LOG(ERROR) << "UnmapAllSnapshots failed";
+ return false;
+ }
+
+ LOG(INFO) << "Pre-created snapshots successfully copied";
+ // All snapshots have been written.
+ if (!sm_->FinishedSnapshotWrites(false /* wipe */)) {
+ LOG(ERROR) << "Could not finalize snapshot writes.\n";
+ return false;
+ }
+
+ auto hal = hal::BootControlClient::WaitForService();
+ if (!hal) {
+ LOG(ERROR) << "Could not find IBootControl HAL.\n";
+ return false;
+ }
+ auto target_slot_number = SlotNumberForSlotSuffix(target_slot);
+ auto cr = hal->SetActiveBootSlot(target_slot_number);
+ if (!cr.IsOk()) {
+ LOG(ERROR) << "Could not set active boot slot: " << cr.errMsg;
+ return false;
+ }
+
+ LOG(INFO) << "ApplyUpdate success";
+ return true;
+}
+
bool MapSnapshots::BeginUpdate() {
lock_ = sm_->LockExclusive();
std::vector<std::string> snapshots;
@@ -227,11 +413,10 @@
if (file_offset >= dev_sz) {
break;
}
-
- if (fsync(cfd.get()) < 0) {
- PLOG(ERROR) << "Fsync failed at offset: " << file_offset << " size: " << to_read;
- return false;
- }
+ }
+ if (fsync(cfd.get()) < 0) {
+ PLOG(ERROR) << "Fsync failed";
+ return false;
}
return true;
}
@@ -279,23 +464,23 @@
}
bool DumpCmdHandler(int /*argc*/, char** argv) {
- android::base::InitLogging(argv, &android::base::StderrLogger);
+ android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
return SnapshotManager::New()->Dump(std::cout);
}
bool MapCmdHandler(int, char** argv) {
- android::base::InitLogging(argv, &android::base::StderrLogger);
+ android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
using namespace std::chrono_literals;
return SnapshotManager::New()->MapAllSnapshots(5000ms);
}
bool UnmapCmdHandler(int, char** argv) {
- android::base::InitLogging(argv, &android::base::StderrLogger);
+ android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
return SnapshotManager::New()->UnmapAllSnapshots();
}
bool MergeCmdHandler(int /*argc*/, char** argv) {
- android::base::InitLogging(argv, &android::base::StderrLogger);
+ android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
LOG(WARNING) << "Deprecated. Call update_engine_client --merge instead.";
return false;
}
@@ -367,6 +552,30 @@
return snapshot.DeleteSnapshots();
}
+bool ApplyUpdate(int argc, char** argv) {
+ android::base::InitLogging(argv, &android::base::KernelLogger);
+
+ // Make sure we are root.
+ if (::getuid() != 0) {
+ LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+ return EXIT_FAILURE;
+ }
+
+ if (argc < 3) {
+ std::cerr << " apply-update <directory location where snapshot patches are present>"
+ " Apply the snapshots to the COW block device\n";
+ return false;
+ }
+
+ std::string path = std::string(argv[2]);
+ MapSnapshots cow(path);
+ if (!cow.ApplyUpdate()) {
+ return false;
+ }
+ LOG(INFO) << "Apply update success. Please reboot the device";
+ return true;
+}
+
bool MapPrecreatedSnapshots(int argc, char** argv) {
android::base::InitLogging(argv, &android::base::KernelLogger);
@@ -554,6 +763,7 @@
{"test-blank-ota", TestOtaHandler},
#endif
{"unmap", UnmapCmdHandler},
+ {"apply-update", ApplyUpdate},
{"map-snapshots", MapPrecreatedSnapshots},
{"unmap-snapshots", UnMapPrecreatedSnapshots},
{"delete-snapshots", DeletePrecreatedSnapshots},
diff --git a/fs_mgr/libsnapshot/vts_ota_config_test.cpp b/fs_mgr/libsnapshot/vts_ota_config_test.cpp
index d387eb3..b5618c4 100755
--- a/fs_mgr/libsnapshot/vts_ota_config_test.cpp
+++ b/fs_mgr/libsnapshot/vts_ota_config_test.cpp
@@ -21,6 +21,7 @@
return android::base::GetIntProperty("ro.vendor.api_level", -1);
}
+// @VsrTest = 3.7.6
TEST(VAB, Enabled) {
if (!android::base::GetBoolProperty("ro.build.ab_update", false) && (GetVsrLevel() < __ANDROID_API_T__)) {
GTEST_SKIP();
diff --git a/fs_mgr/tests/adb-remount-test.sh b/fs_mgr/tests/adb-remount-test.sh
index 7ac7a16..526c761 100755
--- a/fs_mgr/tests/adb-remount-test.sh
+++ b/fs_mgr/tests/adb-remount-test.sh
@@ -1081,7 +1081,9 @@
LOG RUN "Testing adb disable-verity -R"
T=$(adb_date)
-adb_su disable-verity -R >&2 ||
+adb_su disable-verity -R >&2
+err=${?}
+[[ ${err} -eq 0 || ${err} -eq 255 ]] ||
die -t "${T}" "disable-verity -R failed"
sleep 2
adb_wait "${ADB_WAIT}" ||
@@ -1192,7 +1194,9 @@
LOG RUN "Testing adb remount -R"
T=$(adb_date)
-adb_su remount -R </dev/null >&2 ||
+adb_su remount -R </dev/null >&2
+err=${?}
+[[ ${err} -eq 0 || ${err} -eq 255 ]] ||
die -t "${T}" "adb remount -R failed"
sleep 2
adb_wait "${ADB_WAIT}" ||
diff --git a/fs_mgr/tools/dmctl.cpp b/fs_mgr/tools/dmctl.cpp
index 5d5c650..f843821 100644
--- a/fs_mgr/tools/dmctl.cpp
+++ b/fs_mgr/tools/dmctl.cpp
@@ -116,6 +116,21 @@
std::string block_device = NextArg();
return std::make_unique<DmTargetAndroidVerity>(start_sector, num_sectors, keyid,
block_device);
+ } else if (target_type == "striped") {
+ if (!HasArgs(3)) {
+ std::cerr << "Expected \"striped\" <block_device0> <block_device1> <chunksize>"
+ << std::endl;
+ return nullptr;
+ }
+ std::string block_device0 = NextArg();
+ std::string block_device1 = NextArg();
+ uint64_t chunk_size;
+ if (!android::base::ParseUint(NextArg(), &chunk_size)) {
+ std::cerr << "Expected start sector, got: " << PreviousArg() << std::endl;
+ return nullptr;
+ }
+ return std::make_unique<DmTargetStripe>(start_sector, num_sectors, chunk_size,
+ block_device0, block_device1);
} else if (target_type == "bow") {
if (!HasArgs(1)) {
std::cerr << "Expected \"bow\" <block_device>" << std::endl;
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..12ca15a 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 {
@@ -163,6 +162,7 @@
},
static_libs: [
"libavb",
+ "libavf_cc_flags",
"libbootloader_message",
"libc++fs",
"libcgrouprc_format",
@@ -321,7 +321,6 @@
visibility: ["//packages/modules/Virtualization/microdroid"],
}
-
soong_config_module_type {
name: "init_first_stage_cc_defaults",
module_type: "cc_defaults",
@@ -361,6 +360,7 @@
static_libs: [
"libc++fs",
"libfs_avb",
+ "libavf_cc_flags",
"libfs_mgr",
"libfec",
"libfec_rs",
@@ -461,7 +461,10 @@
cc_binary {
name: "init_first_stage.microdroid",
- defaults: ["init_first_stage_defaults"],
+ defaults: [
+ "avf_build_flags_cc",
+ "init_first_stage_defaults",
+ ],
cflags: ["-DMICRODROID=1"],
installable: false,
}
@@ -599,7 +602,6 @@
},
generated_headers: [
"generated_stub_builtin_function_map",
- "generated_android_ids",
],
target: {
android: {
@@ -614,13 +616,16 @@
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,
+ generated_headers: [
+ "generated_android_ids",
+ ],
}
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/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 05e00ed..a686d05 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -132,11 +132,19 @@
bool BlockDevInitializer::InitDmDevice(const std::string& device) {
const std::string device_name(basename(device.c_str()));
const std::string syspath = "/sys/block/" + device_name;
+ return InitDevice(syspath, device_name);
+}
+
+bool BlockDevInitializer::InitPlatformDevice(const std::string& dev_name) {
+ return InitDevice("/sys/devices/platform", dev_name);
+}
+
+bool BlockDevInitializer::InitDevice(const std::string& syspath, const std::string& device_name) {
bool found = false;
- auto uevent_callback = [&device_name, &device, this, &found](const Uevent& uevent) {
+ auto uevent_callback = [&device_name, this, &found](const Uevent& uevent) {
if (uevent.device_name == device_name) {
- LOG(VERBOSE) << "Creating device-mapper device : " << device;
+ LOG(VERBOSE) << "Creating device : " << device_name;
device_handler_->HandleUevent(uevent);
found = true;
return ListenerAction::kStop;
@@ -146,13 +154,13 @@
uevent_listener_.RegenerateUeventsForPath(syspath, uevent_callback);
if (!found) {
- LOG(INFO) << "dm device '" << device << "' not found in /sys, waiting for its uevent";
+ LOG(INFO) << "device '" << device_name << "' not found in /sys, waiting for its uevent";
Timer t;
uevent_listener_.Poll(uevent_callback, 10s);
- LOG(INFO) << "wait for dm device '" << device << "' returned after " << t;
+ LOG(INFO) << "wait for device '" << device_name << "' returned after " << t;
}
if (!found) {
- LOG(ERROR) << "dm device '" << device << "' not found after polling timeout";
+ LOG(ERROR) << "device '" << device_name << "' not found after polling timeout";
return false;
}
return true;
diff --git a/init/block_dev_initializer.h b/init/block_dev_initializer.h
index ec39ce0..d5b1f60 100644
--- a/init/block_dev_initializer.h
+++ b/init/block_dev_initializer.h
@@ -24,6 +24,7 @@
namespace android {
namespace init {
+// TODO: should this be renamed to FirstStageDevInitialize?
class BlockDevInitializer final {
public:
BlockDevInitializer();
@@ -32,11 +33,13 @@
bool InitDmUser(const std::string& name);
bool InitDevices(std::set<std::string> devices);
bool InitDmDevice(const std::string& device);
+ bool InitPlatformDevice(const std::string& device);
private:
ListenerAction HandleUevent(const Uevent& uevent, std::set<std::string>* devices);
bool InitMiscDevice(const std::string& name);
+ bool InitDevice(const std::string& syspath, const std::string& device);
std::unique_ptr<DeviceHandler> device_handler_;
UeventListener uevent_listener_;
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..f6f9329 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -16,6 +16,7 @@
#include "first_stage_console.h"
+#include <spawn.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
@@ -65,19 +66,20 @@
return true;
}
-static void RunScript() {
- LOG(INFO) << "Attempting to run /first_stage.sh...";
- pid_t pid = fork();
- if (pid != 0) {
- int status;
- waitpid(pid, &status, 0);
- LOG(INFO) << "/first_stage.sh exited with status " << status;
- return;
- }
- const char* path = "/system/bin/sh";
- 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;
+static pid_t SpawnImage(const char* file) {
+ const char* argv[] = {file, NULL};
+ const char* envp[] = {NULL};
+
+ char* const* argvp = const_cast<char* const*>(argv);
+ char* const* envpp = const_cast<char* const*>(envp);
+
+ pid_t pid;
+ errno = posix_spawn(&pid, argv[0], NULL, NULL, argvp, envpp);
+ if (!errno) return pid;
+
+ PLOG(ERROR) << "Failed to spawn '" << file << "'";
+
+ return (pid_t)0;
}
namespace android {
@@ -86,24 +88,28 @@
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();
if (pid != 0) {
- int status;
- waitpid(pid, &status, 0);
- LOG(ERROR) << "console shell exited with status " << status;
+ wait(NULL);
+ LOG(ERROR) << "console shell exited";
return;
}
if (console) console = SetupConsole();
- RunScript();
+
+ LOG(INFO) << "Attempting to run /first_stage.sh...";
+ if (SpawnImage("/first_stage.sh")) {
+ wait(NULL);
+ LOG(INFO) << "/first_stage.sh exited";
+ }
+
if (console) {
- const char* path = "/system/bin/sh";
- const char* args[] = {path, nullptr};
- int rv = execv(path, const_cast<char**>(args));
- LOG(ERROR) << "unable to execv, returned " << rv << " errno " << errno;
+ if (SpawnImage("/system/bin/sh")) wait(NULL);
}
_exit(127);
}
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index c4d0f75..356aaa0 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -37,6 +37,7 @@
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
+#include <android/avf_cc_flags.h>
#include <modprobe/modprobe.h>
#include <private/android_filesystem_config.h>
@@ -385,7 +386,12 @@
// /second_stage_resources is used to preserve files from first to second
// stage init
CHECKCALL(mount("tmpfs", kSecondStageRes, "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
- "mode=0755,uid=0,gid=0"))
+ "mode=0755,uid=0,gid=0"));
+
+ if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+ CHECKCALL(mount("tmpfs", "/microdroid_resources", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
+ "mode=0750,uid=0,gid=0"));
+ }
#undef CHECKCALL
SetStdioToDevNull(argv);
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index c0b9281..836d536 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -16,6 +16,7 @@
#include "first_stage_mount.h"
+#include <signal.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <unistd.h>
@@ -33,6 +34,7 @@
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
+#include <android/avf_cc_flags.h>
#include <fs_avb/fs_avb.h>
#include <fs_mgr.h>
#include <fs_mgr_dm_linear.h>
@@ -272,6 +274,11 @@
return true;
}
+// TODO: should this be in a library in packages/modules/Virtualization first_stage_init links?
+static bool IsMicrodroidStrictBoot() {
+ return access("/proc/device-tree/chosen/avf,strict-boot", F_OK) == 0;
+}
+
bool FirstStageMountVBootV2::InitDevices() {
std::set<std::string> devices;
GetSuperDeviceName(&devices);
@@ -283,6 +290,14 @@
return false;
}
+ if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+ if (IsMicrodroidStrictBoot()) {
+ if (!block_dev_init_.InitPlatformDevice("open-dice0")) {
+ return false;
+ }
+ }
+ }
+
if (IsDmLinearEnabled()) {
auto super_symlink = "/dev/block/by-name/"s + super_partition_name_;
if (!android::base::Realpath(super_symlink, &super_path_)) {
@@ -527,9 +542,48 @@
return true;
}
+static bool MaybeDeriveMicrodroidVendorDiceNode(Fstab* fstab) {
+ std::optional<std::string> microdroid_vendor_block_dev;
+ for (auto entry = fstab->begin(); entry != fstab->end(); entry++) {
+ if (entry->mount_point == "/vendor") {
+ microdroid_vendor_block_dev.emplace(entry->blk_device);
+ break;
+ }
+ }
+ if (!microdroid_vendor_block_dev.has_value()) {
+ LOG(VERBOSE) << "No microdroid vendor partition to mount";
+ return true;
+ }
+ // clang-format off
+ const std::array<const char*, 7> args = {
+ "/system/bin/derive_microdroid_vendor_dice_node",
+ "--dice-driver", "/dev/open-dice0",
+ "--microdroid-vendor-disk-image", microdroid_vendor_block_dev->data(),
+ "--output", "/microdroid_resources/dice_chain.raw",
+ };
+ // clang-format-on
+ // ForkExecveAndWaitForCompletion calls waitpid to wait for the fork-ed process to finish.
+ // The first_stage_console adds SA_NOCLDWAIT flag to the SIGCHLD handler, which means that
+ // waitpid will always return -ECHLD. Here we re-register a default handler, so that waitpid
+ // works.
+ LOG(INFO) << "Deriving dice node for microdroid vendor partition";
+ signal(SIGCHLD, SIG_DFL);
+ if (!ForkExecveAndWaitForCompletion(args[0], (char**)args.data())) {
+ LOG(ERROR) << "Failed to derive microdroid vendor dice node";
+ return false;
+ }
+ return true;
+}
+
bool FirstStageMountVBootV2::MountPartitions() {
if (!TrySwitchSystemAsRoot()) return false;
+ if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+ if (!MaybeDeriveMicrodroidVendorDiceNode(&fstab_)) {
+ return false;
+ }
+ }
+
if (!SkipMountingPartitions(&fstab_, true /* verbose */)) return false;
for (auto current = fstab_.begin(); current != fstab_.end();) {
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/persistent_properties.cpp b/init/persistent_properties.cpp
index 6f8a4de..59e57b9 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -23,6 +23,7 @@
#include <sys/types.h>
#include <memory>
+#include <unordered_map>
#include <android-base/file.h>
#include <android-base/logging.h>
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 30ad800..58a0a7f 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -58,6 +58,7 @@
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <fs_mgr.h>
+#include <private/android_filesystem_config.h>
#include <property_info_parser/property_info_parser.h>
#include <property_info_serializer/property_info_serializer.h>
#include <selinux/android.h>
@@ -117,12 +118,13 @@
static bool persistent_properties_loaded = false;
-static int property_set_fd = -1;
static int from_init_socket = -1;
static int init_socket = -1;
static bool accept_messages = false;
static std::mutex accept_messages_lock;
+static std::mutex selinux_check_access_lock;
static std::thread property_service_thread;
+static std::thread property_service_for_system_thread;
static std::unique_ptr<PersistWriteThread> persist_write_thread;
@@ -167,6 +169,7 @@
ucred cr = {.pid = 0, .uid = 0, .gid = 0};
audit_data.cr = &cr;
+ auto lock = std::lock_guard{selinux_check_access_lock};
return selinux_check_access(source_context.c_str(), target_context, "file", "read",
&audit_data) == 0;
}
@@ -182,10 +185,9 @@
audit_data.name = name.c_str();
audit_data.cr = &cr;
- bool has_access = (selinux_check_access(source_context, target_context, "property_service",
- "set", &audit_data) == 0);
-
- return has_access;
+ auto lock = std::lock_guard{selinux_check_access_lock};
+ return selinux_check_access(source_context, target_context, "property_service", "set",
+ &audit_data) == 0;
}
void NotifyPropertyChange(const std::string& name, const std::string& value) {
@@ -400,30 +402,38 @@
return {PROP_ERROR_INVALID_VALUE};
}
- prop_info* pi = (prop_info*)__system_property_find(name.c_str());
- if (pi != nullptr) {
- // ro.* properties are actually "write-once".
- if (StartsWith(name, "ro.")) {
- *error = "Read-only property was already set";
- return {PROP_ERROR_READ_ONLY_PROPERTY};
- }
-
- __system_property_update(pi, value.c_str(), valuelen);
+ if (name == "sys.powerctl") {
+ // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
+ // can come to the second thread, we mustn't call out to the __system_property_* functions
+ // which support multiple readers but only one mutator.
} else {
- int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
- if (rc < 0) {
- *error = "__system_property_add failed";
- return {PROP_ERROR_SET_FAILED};
- }
- }
+ prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+ if (pi != nullptr) {
+ // ro.* properties are actually "write-once".
+ if (StartsWith(name, "ro.")) {
+ *error = "Read-only property was already set";
+ return {PROP_ERROR_READ_ONLY_PROPERTY};
+ }
- bool need_persist = StartsWith(name, "persist.") || StartsWith(name, "next_boot.");
- if (socket && persistent_properties_loaded && need_persist) {
- if (persist_write_thread) {
- persist_write_thread->Write(name, value, std::move(*socket));
- return {};
+ __system_property_update(pi, value.c_str(), valuelen);
+ } else {
+ int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+ if (rc < 0) {
+ *error = "__system_property_add failed";
+ return {PROP_ERROR_SET_FAILED};
+ }
}
- WritePersistentProperty(name, value);
+
+ // Don't write properties to disk until after we have read all default
+ // properties to prevent them from being overwritten by default values.
+ bool need_persist = StartsWith(name, "persist.") || StartsWith(name, "next_boot.");
+ if (socket && persistent_properties_loaded && need_persist) {
+ if (persist_write_thread) {
+ persist_write_thread->Write(name, value, std::move(*socket));
+ return {};
+ }
+ WritePersistentProperty(name, value);
+ }
}
NotifyPropertyChange(name, value);
@@ -584,10 +594,10 @@
return *ret;
}
-static void handle_property_set_fd() {
+static void handle_property_set_fd(int fd) {
static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
- int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
+ int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
if (s == -1) {
return;
}
@@ -1090,6 +1100,12 @@
// required to support.
constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
+ if (__system_property_find(VENDOR_API_LEVEL_PROP) != nullptr) {
+ // The device already have ro.vendor.api_level in its vendor/build.prop.
+ // Skip initializing the ro.vendor.api_level property.
+ return;
+ }
+
auto vendor_api_level = GetIntProperty("ro.board.first_api_level", __ANDROID_VENDOR_API_MAX__);
if (vendor_api_level != __ANDROID_VENDOR_API_MAX__) {
// Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
@@ -1104,7 +1120,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 "
@@ -1294,7 +1311,7 @@
mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
false)) {
- PLOG(ERROR) << "Unable to write vendor overrides to file";
+ PLOG(ERROR) << "Unable to write appcompat override property infos to file";
}
selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
}
@@ -1431,19 +1448,21 @@
}
}
-static void PropertyServiceThread() {
+static void PropertyServiceThread(int fd, bool listen_init) {
Epoll epoll;
if (auto result = epoll.Open(); !result.ok()) {
LOG(FATAL) << result.error();
}
- if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
+ if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
!result.ok()) {
LOG(FATAL) << result.error();
}
- if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
- LOG(FATAL) << result.error();
+ if (listen_init) {
+ if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+ LOG(FATAL) << result.error();
+ }
}
while (true) {
@@ -1492,6 +1511,23 @@
cv_.notify_all();
}
+void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
+ int fd = -1;
+ if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+ /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
+ /*gid=*/gid, /*socketcon=*/{});
+ result.ok()) {
+ fd = *result;
+ } else {
+ LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+ }
+
+ listen(fd, 8);
+
+ auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
+ t.swap(new_thread);
+}
+
void StartPropertyService(int* epoll_socket) {
InitPropertySet("ro.property_service.version", "2");
@@ -1503,19 +1539,9 @@
init_socket = sockets[1];
StartSendingMessages();
- if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
- /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
- /*gid=*/0, /*socketcon=*/{});
- result.ok()) {
- property_set_fd = *result;
- } else {
- LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
- }
-
- listen(property_set_fd, 8);
-
- auto new_thread = std::thread{PropertyServiceThread};
- property_service_thread.swap(new_thread);
+ StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
+ true);
+ StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
auto async_persist_writes =
android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);
diff --git a/init/reboot.cpp b/init/reboot.cpp
index 1a26c4d..150f8f4 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -1083,7 +1083,8 @@
return;
}
}
- } else if (reboot_target == "quiescent") {
+ } else if (std::find(cmd_params.begin(), cmd_params.end(), "quiescent")
+ != cmd_params.end()) { // Quiescent can be either subreason or details.
bootloader_message boot = {};
if (std::string err; !read_bootloader_message(&boot, &err)) {
LOG(ERROR) << "Failed to read bootloader message: " << err;
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 1f211dd..e191b60 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -111,97 +111,6 @@
return true;
}
-// Forks, executes the provided program in the child, and waits for the completion in the parent.
-// Child's stderr is captured and logged using LOG(ERROR).
-bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]) {
- // Create a pipe used for redirecting child process's output.
- // * pipe_fds[0] is the FD the parent will use for reading.
- // * pipe_fds[1] is the FD the child will use for writing.
- int pipe_fds[2];
- if (pipe(pipe_fds) == -1) {
- PLOG(ERROR) << "Failed to create pipe";
- return false;
- }
-
- pid_t child_pid = fork();
- if (child_pid == -1) {
- PLOG(ERROR) << "Failed to fork for " << filename;
- return false;
- }
-
- if (child_pid == 0) {
- // fork succeeded -- this is executing in the child process
-
- // Close the pipe FD not used by this process
- close(pipe_fds[0]);
-
- // Redirect stderr to the pipe FD provided by the parent
- if (TEMP_FAILURE_RETRY(dup2(pipe_fds[1], STDERR_FILENO)) == -1) {
- PLOG(ERROR) << "Failed to redirect stderr of " << filename;
- _exit(127);
- return false;
- }
- close(pipe_fds[1]);
-
- if (execv(filename, argv) == -1) {
- PLOG(ERROR) << "Failed to execve " << filename;
- return false;
- }
- // Unreachable because execve will have succeeded and replaced this code
- // with child process's code.
- _exit(127);
- return false;
- } else {
- // fork succeeded -- this is executing in the original/parent process
-
- // Close the pipe FD not used by this process
- close(pipe_fds[1]);
-
- // Log the redirected output of the child process.
- // It's unfortunate that there's no standard way to obtain an istream for a file descriptor.
- // As a result, we're buffering all output and logging it in one go at the end of the
- // invocation, instead of logging it as it comes in.
- const int child_out_fd = pipe_fds[0];
- std::string child_output;
- if (!android::base::ReadFdToString(child_out_fd, &child_output)) {
- PLOG(ERROR) << "Failed to capture full output of " << filename;
- }
- close(child_out_fd);
- if (!child_output.empty()) {
- // Log captured output, line by line, because LOG expects to be invoked for each line
- std::istringstream in(child_output);
- std::string line;
- while (std::getline(in, line)) {
- LOG(ERROR) << filename << ": " << line;
- }
- }
-
- // Wait for child to terminate
- int status;
- if (TEMP_FAILURE_RETRY(waitpid(child_pid, &status, 0)) != child_pid) {
- PLOG(ERROR) << "Failed to wait for " << filename;
- return false;
- }
-
- if (WIFEXITED(status)) {
- int status_code = WEXITSTATUS(status);
- if (status_code == 0) {
- return true;
- } else {
- LOG(ERROR) << filename << " exited with status " << status_code;
- }
- } else if (WIFSIGNALED(status)) {
- LOG(ERROR) << filename << " killed by signal " << WTERMSIG(status);
- } else if (WIFSTOPPED(status)) {
- LOG(ERROR) << filename << " stopped by signal " << WSTOPSIG(status);
- } else {
- LOG(ERROR) << "waitpid for " << filename << " returned unexpected status: " << status;
- }
-
- return false;
- }
-}
-
bool ReadFirstLine(const char* file, std::string* line) {
line->clear();
diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index 3a78343..dea7af9 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -195,22 +195,20 @@
return;
}
auto start = reinterpret_cast<const void*>(map.start);
- auto len = map.end - map.start;
+ uint64_t len = android::procinfo::MappedFileSize(map);
if (!len) {
return;
}
+
if (mlock(start, len) < 0) {
- LOG(ERROR) << "mlock failed, " << start << " for " << len << " bytes.";
+ PLOG(ERROR) << "\"" << map.name << "\": mlock(" << start << ", " << len
+ << ") failed: pgoff = " << map.pgoff;
ok = false;
}
};
if (!android::procinfo::ReadProcessMaps(getpid(), callback) || !ok) {
- LOG(FATAL) << "Could not process /proc/" << getpid() << "/maps file for init, "
- << "falling back to mlockall().";
- if (mlockall(MCL_CURRENT) < 0) {
- LOG(FATAL) << "mlockall failed";
- }
+ LOG(FATAL) << "Could not process /proc/" << getpid() << "/maps file for init";
}
}
diff --git a/init/util.cpp b/init/util.cpp
index e760a59..e5efc7d 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -27,6 +27,7 @@
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
+#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
@@ -747,5 +748,96 @@
return filtered_configs;
}
+// Forks, executes the provided program in the child, and waits for the completion in the parent.
+// Child's stderr is captured and logged using LOG(ERROR).
+bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]) {
+ // Create a pipe used for redirecting child process's output.
+ // * pipe_fds[0] is the FD the parent will use for reading.
+ // * pipe_fds[1] is the FD the child will use for writing.
+ int pipe_fds[2];
+ if (pipe(pipe_fds) == -1) {
+ PLOG(ERROR) << "Failed to create pipe";
+ return false;
+ }
+
+ pid_t child_pid = fork();
+ if (child_pid == -1) {
+ PLOG(ERROR) << "Failed to fork for " << filename;
+ return false;
+ }
+
+ if (child_pid == 0) {
+ // fork succeeded -- this is executing in the child process
+
+ // Close the pipe FD not used by this process
+ close(pipe_fds[0]);
+
+ // Redirect stderr to the pipe FD provided by the parent
+ if (TEMP_FAILURE_RETRY(dup2(pipe_fds[1], STDERR_FILENO)) == -1) {
+ PLOG(ERROR) << "Failed to redirect stderr of " << filename;
+ _exit(127);
+ return false;
+ }
+ close(pipe_fds[1]);
+
+ if (execv(filename, argv) == -1) {
+ PLOG(ERROR) << "Failed to execve " << filename;
+ return false;
+ }
+ // Unreachable because execve will have succeeded and replaced this code
+ // with child process's code.
+ _exit(127);
+ return false;
+ } else {
+ // fork succeeded -- this is executing in the original/parent process
+
+ // Close the pipe FD not used by this process
+ close(pipe_fds[1]);
+
+ // Log the redirected output of the child process.
+ // It's unfortunate that there's no standard way to obtain an istream for a file descriptor.
+ // As a result, we're buffering all output and logging it in one go at the end of the
+ // invocation, instead of logging it as it comes in.
+ const int child_out_fd = pipe_fds[0];
+ std::string child_output;
+ if (!android::base::ReadFdToString(child_out_fd, &child_output)) {
+ PLOG(ERROR) << "Failed to capture full output of " << filename;
+ }
+ close(child_out_fd);
+ if (!child_output.empty()) {
+ // Log captured output, line by line, because LOG expects to be invoked for each line
+ std::istringstream in(child_output);
+ std::string line;
+ while (std::getline(in, line)) {
+ LOG(ERROR) << filename << ": " << line;
+ }
+ }
+
+ // Wait for child to terminate
+ int status;
+ if (TEMP_FAILURE_RETRY(waitpid(child_pid, &status, 0)) != child_pid) {
+ PLOG(ERROR) << "Failed to wait for " << filename;
+ return false;
+ }
+
+ if (WIFEXITED(status)) {
+ int status_code = WEXITSTATUS(status);
+ if (status_code == 0) {
+ return true;
+ } else {
+ LOG(ERROR) << filename << " exited with status " << status_code;
+ }
+ } else if (WIFSIGNALED(status)) {
+ LOG(ERROR) << filename << " killed by signal " << WTERMSIG(status);
+ } else if (WIFSTOPPED(status)) {
+ LOG(ERROR) << filename << " stopped by signal " << WSTOPSIG(status);
+ } else {
+ LOG(ERROR) << "waitpid for " << filename << " returned unexpected status: " << status;
+ }
+
+ return false;
+ }
+}
+
} // namespace init
} // namespace android
diff --git a/init/util.h b/init/util.h
index 2d02182..aa24123 100644
--- a/init/util.h
+++ b/init/util.h
@@ -117,5 +117,10 @@
// (.rc == .0rc for ranking purposes)
std::vector<std::string> FilterVersionedConfigs(const std::vector<std::string>& configs,
int active_sdk);
+
+// Forks, executes the provided program in the child, and waits for the completion in the parent.
+// Child's stderr is captured and logged using LOG(ERROR).
+bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]);
+
} // namespace init
} // namespace android
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 8ae7d9e..b7752d9 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -116,27 +116,6 @@
},
}
-cc_test {
- name: "libcutils_sockets_test",
- test_suites: ["device-tests"],
- static_libs: ["libbase", "libcutils_sockets"],
- cflags: [
- "-Wall",
- "-Wextra",
- "-Werror",
- ],
-
- srcs: ["sockets_test.cpp"],
- target: {
- android: {
- srcs: [
- "android_get_control_file_test.cpp",
- "android_get_control_socket_test.cpp",
- ],
- },
- },
-}
-
// some files must not be compiled when building against Mingw
// they correspond to features not used by our host development tools
// which are also hard or even impossible to port to native Win32
@@ -347,7 +326,10 @@
cc_test {
name: "KernelLibcutilsTest",
- test_suites: ["general-tests", "vts"],
+ test_suites: [
+ "general-tests",
+ "vts",
+ ],
defaults: ["libcutils_test_static_defaults"],
test_config: "KernelLibcutilsTest.xml",
}
diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 410dbfd..46b8ef2 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -301,6 +301,12 @@
return -1;
}
+ // forbid size changes to match ashmem behaviour
+ if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) == -1) {
+ ALOGE("memfd_create(%s, %zd) F_ADD_SEALS failed: %m", name, size);
+ return -1;
+ }
+
if (debug_log) {
ALOGE("memfd_create(%s, %zd) success. fd=%d\n", name, size, fd.get());
}
@@ -352,14 +358,29 @@
}
static int memfd_set_prot_region(int fd, int prot) {
- /* Only proceed if an fd needs to be write-protected */
+ int seals = fcntl(fd, F_GET_SEALS);
+ if (seals == -1) {
+ ALOGE("memfd_set_prot_region(%d, %d): F_GET_SEALS failed: %s\n", fd, prot, strerror(errno));
+ return -1;
+ }
+
if (prot & PROT_WRITE) {
+ /* Now we want the buffer to be read-write, let's check if the buffer
+ * has been previously marked as read-only before, if so return error
+ */
+ if (seals & F_SEAL_FUTURE_WRITE) {
+ ALOGE("memfd_set_prot_region(%d, %d): region is write protected\n", fd, prot);
+ errno = EINVAL; // inline with ashmem error code, if already in
+ // read-only mode
+ return -1;
+ }
return 0;
}
- if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
- ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %s\n", fd, prot,
- strerror(errno));
+ /* We would only allow read-only for any future file operations */
+ if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE | F_SEAL_SEAL) == -1) {
+ ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE | F_SEAL_SEAL seal failed: %s\n",
+ fd, prot, strerror(errno));
return -1;
}
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/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 5d79d6a..d7a90c4 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -41,6 +41,7 @@
std::vector<std::string>* post_dependencies);
void ResetModuleCount() { module_count_ = 0; }
int GetModuleCount() { return module_count_; }
+ bool IsBlocklisted(const std::string& module_name);
private:
std::string MakeCanonical(const std::string& module_path);
@@ -52,7 +53,6 @@
void AddOption(const std::string& module_name, const std::string& option_name,
const std::string& value);
std::string GetKernelCmdline();
- bool IsBlocklisted(const std::string& module_name);
bool ParseDepCallback(const std::string& base_path, const std::vector<std::string>& args);
bool ParseAliasCallback(const std::vector<std::string>& args);
diff --git a/libutils/binder/RefBase_test.cpp b/libutils/binder/RefBase_test.cpp
index d675598..65d40a2 100644
--- a/libutils/binder/RefBase_test.cpp
+++ b/libutils/binder/RefBase_test.cpp
@@ -300,8 +300,8 @@
std::atomic<int>* mDeleteCount;
};
-static sp<Bar> buffer;
-static std::atomic<bool> bufferFull(false);
+[[clang::no_destroy]] static constinit sp<Bar> buffer;
+static constinit std::atomic<bool> bufferFull(false);
// Wait until bufferFull has value val.
static inline void waitFor(bool val) {
@@ -380,8 +380,8 @@
} // Otherwise this is slow and probably pointless on a uniprocessor.
}
-static wp<Bar> wpBuffer;
-static std::atomic<bool> wpBufferFull(false);
+[[clang::no_destroy]] static constinit wp<Bar> wpBuffer;
+static constinit std::atomic<bool> wpBufferFull(false);
// Wait until wpBufferFull has value val.
static inline void wpWaitFor(bool val) {
diff --git a/libutils/binder/include/utils/RefBase.h b/libutils/binder/include/utils/RefBase.h
index 5e3fa7d..f03e1be 100644
--- a/libutils/binder/include/utils/RefBase.h
+++ b/libutils/binder/include/utils/RefBase.h
@@ -404,7 +404,7 @@
public:
typedef typename RefBase::weakref_type weakref_type;
- inline wp() : m_ptr(nullptr), m_refs(nullptr) { }
+ inline constexpr wp() : m_ptr(nullptr), m_refs(nullptr) { }
// if nullptr, returns nullptr
//
diff --git a/libutils/binder/include/utils/StrongPointer.h b/libutils/binder/include/utils/StrongPointer.h
index 43c00c9..fb9b8e8 100644
--- a/libutils/binder/include/utils/StrongPointer.h
+++ b/libutils/binder/include/utils/StrongPointer.h
@@ -30,7 +30,7 @@
template<typename T>
class sp {
public:
- inline sp() : m_ptr(nullptr) { }
+ inline constexpr sp() : m_ptr(nullptr) { }
// The old way of using sp<> was like this. This is bad because it relies
// on implicit conversion to sp<>, which we would like to remove (if an
diff --git a/libutils/include/utils/CallStack.h b/libutils/include/utils/CallStack.h
index fe4d4f5..0239b68 100644
--- a/libutils/include/utils/CallStack.h
+++ b/libutils/include/utils/CallStack.h
@@ -14,8 +14,7 @@
* limitations under the License.
*/
-#ifndef ANDROID_CALLSTACK_H
-#define ANDROID_CALLSTACK_H
+#pragma once
#include <memory>
@@ -27,17 +26,19 @@
#include <sys/types.h>
#if !defined(__APPLE__) && !defined(_WIN32)
-# define WEAKS_AVAILABLE 1
+# define CALLSTACK_WEAKS_AVAILABLE 1
#endif
#ifndef CALLSTACK_WEAK
-# ifdef WEAKS_AVAILABLE
+# ifdef CALLSTACK_WEAKS_AVAILABLE
# define CALLSTACK_WEAK __attribute__((weak))
-# else // !WEAKS_AVAILABLE
+# else // !CALLSTACK_WEAKS_AVAILABLE
# define CALLSTACK_WEAK
-# endif // !WEAKS_AVAILABLE
+# endif // !CALLSTACK_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 {
@@ -89,7 +90,7 @@
//
// DO NOT USE THESE. They will disappear.
struct StackDeleter {
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
void operator()(CallStack* stack) {
deleteStack(stack);
}
@@ -101,8 +102,8 @@
typedef std::unique_ptr<CallStack, StackDeleter> CallStackUPtr;
// Return current call stack if possible, nullptr otherwise.
-#ifdef WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
+#ifdef CALLSTACK_WEAKS_AVAILABLE
+ 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);
@@ -110,15 +111,16 @@
return getCurrentInternal(ignoreDepth);
}
}
-#else // !WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t = 1) {
+#else // !CALLSTACK_WEAKS_AVAILABLE
+ static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t = 1) {
return CallStackUPtr(nullptr);
}
-#endif // !WEAKS_AVAILABLE
+#endif // !CALLSTACK_WEAKS_AVAILABLE
-#ifdef WEAKS_AVAILABLE
- static void ALWAYS_INLINE logStack(const char* logtag, CallStack* stack = getCurrent().get(),
- android_LogPriority priority = ANDROID_LOG_DEBUG) {
+#ifdef CALLSTACK_WEAKS_AVAILABLE
+ 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,30 +129,31 @@
}
#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
+#endif // !CALLSTACK_WEAKS_AVAILABLE
-#ifdef WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* stack = getCurrent().get()) {
+#ifdef CALLSTACK_WEAKS_AVAILABLE
+ 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 {
return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
}
}
-#else // !WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* = getCurrent().get()) {
+#else // !CALLSTACK_WEAKS_AVAILABLE
+ 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
+#endif // !CALLSTACK_WEAKS_AVAILABLE
private:
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
static CallStackUPtr CALLSTACK_WEAK getCurrentInternal(int32_t ignoreDepth);
static void CALLSTACK_WEAK logStackInternal(const char* logtag, const CallStack* stack,
android_LogPriority priority);
@@ -158,11 +161,13 @@
// The deleter is only invoked on non-null pointers. Hence it will never be
// invoked if CallStack is not linked.
static void CALLSTACK_WEAK deleteStack(CallStack* stack);
-#endif // WEAKS_AVAILABLE
+#endif // CALLSTACK_WEAKS_AVAILABLE
Vector<String8> mFrameLines;
};
} // namespace android
-#endif // ANDROID_CALLSTACK_H
+#undef CALLSTACK_WEAKS_AVAILABLE
+#undef CALLSTACK_WEAK
+#undef CALLSTACK_ALWAYS_INLINE
diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index b4457b1..e87959e 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -34,3 +34,32 @@
"liblog",
],
}
+
+cc_library_headers {
+ name: "libvendorsupport_llndk_headers",
+ host_supported: true,
+ vendor_available: true,
+ recovery_available: true,
+ ramdisk_available: true,
+ vendor_ramdisk_available: true,
+ native_bridge_supported: true,
+
+ export_include_dirs: ["include_llndk"],
+ llndk: {
+ llndk_headers: true,
+ },
+
+ apex_available: [
+ "//apex_available:platform",
+ "//apex_available:anyapex",
+ ],
+ min_sdk_version: "apex_inherit",
+
+ system_shared_libs: [],
+ stl: "none",
+
+ // This header library is used for libc and must be available to any sdk
+ // versions.
+ // Setting sdk_version to the lowest version allows the dependencies.
+ sdk_version: "1",
+}
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/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
new file mode 100644
index 0000000..8ae56d4
--- /dev/null
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -0,0 +1,54 @@
+// Copyright (C) 2024 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
+
+/* As a vendor default header included in all vendor modules, this header MUST NOT include other
+ * header files or any declarations. Only macros are allowed.
+ */
+#if defined(__ANDROID_VENDOR__)
+
+// LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
+// NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
+// enabled when the vendor api level is equal to or newer than the ro.board.api_level.
+#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
+ _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+ __attribute__((enable_if( \
+ __ANDROID_VENDOR_API__ >= vendor_api_level, \
+ "available in vendor API level " #vendor_api_level " that " \
+ "is newer than the current vendor API level. Guard the API " \
+ "call with '#if (__ANDROID_VENDOR_API__ >= " #vendor_api_level ")'."))) \
+ _Pragma("clang diagnostic pop")
+
+// Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
+// This returns true for the vendor modules if the vendor_api_level is less than or equal to the
+// ro.board.api_level.
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+ constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
+
+#else // __ANDROID_VENDOR__
+
+// __INTRODUCED_IN_LLNDK is for LLNDK only but not for NDK. Ignore this for non-vendor modules.
+// It leaves a no-op annotation for ABI analysis.
+#if !defined(__INTRODUCED_IN_LLNDK)
+#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
+ __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
+#endif
+
+// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
+// guard the API for __INTRODUCED_IN.
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+ (__builtin_available(android sdk_api_level, *))
+
+#endif // __ANDROID_VENDOR__
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/Android.bp b/rootdir/Android.bp
index c8a3cd6..6a3484e 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -71,3 +71,33 @@
src: "adb_debug.prop",
debug_ramdisk: true,
}
+
+prebuilt_etc {
+ name: "init.zygote64.rc",
+ src: "init.zygote64.rc",
+ sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+ name: "init.zygote32.rc",
+ src: "init.zygote32.rc",
+ sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+ name: "init.zygote64_32.rc",
+ src: "init.zygote64_32.rc",
+ sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+ name: "init.usb.rc",
+ src: "init.usb.rc",
+ sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+ name: "init.usb.configfs.rc",
+ src: "init.usb.configfs.rc",
+ sub_dir: "init/hw",
+}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0646d14..ec203f9 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -247,6 +247,7 @@
write /dev/blkio/background/blkio.bfq.weight 10
write /dev/blkio/blkio.group_idle 0
write /dev/blkio/background/blkio.group_idle 0
+ write /dev/blkio/blkio.prio.class promote-to-rt
write /dev/blkio/background/blkio.prio.class restrict-to-be
restorecon_recursive /mnt
@@ -303,6 +304,9 @@
mkdir /mnt/runtime/full 0755 root root
mkdir /mnt/runtime/full/self 0755 root root
+ # For Pre-reboot Dexopt
+ mkdir /mnt/pre_reboot_dexopt 0755 artd artd
+
# Symlink to keep legacy apps working in multi-user world
symlink /storage/self/primary /mnt/sdcard
symlink /mnt/user/0/primary /mnt/runtime/default/self/primary
@@ -640,6 +644,11 @@
restorecon_recursive /metadata/apex
mkdir /metadata/staged-install 0770 root system
+
+ mkdir /metadata/aconfig 0775 root system
+ mkdir /metadata/aconfig/flags 0770 root system
+ mkdir /metadata/aconfig/boot 0775 root system
+
on late-fs
# Ensure that tracefs has the correct permissions.
# This does not work correctly if it is called in post-fs.
@@ -704,7 +713,7 @@
# Start tombstoned early to be able to store tombstones.
mkdir /data/anr 0775 system system encryption=Require
- mkdir /data/tombstones 0771 system system encryption=Require
+ mkdir /data/tombstones 0775 system system encryption=Require
mkdir /data/vendor/tombstones 0771 root root
mkdir /data/vendor/tombstones/wifi 0771 wifi wifi
start tombstoned
@@ -1353,3 +1362,16 @@
write /sys/kernel/mm/lru_gen/enabled 5
on property:persist.device_config.mglru_native.lru_gen_config=all
write /sys/kernel/mm/lru_gen/enabled 7
+
+# Allow other processes to run `snapshotctl` through `init`. This requires
+# `set_prop` permission on `snapshotctl_prop`.
+on property:sys.snapshotctl.map=requested
+ # "root" is needed to talk to gsid and pass its check on uid.
+ # "system" is needed to write to "/dev/socket/snapuserd" to talk to
+ # snapuserd.
+ exec - root root system -- /system/bin/snapshotctl map
+ setprop sys.snapshotctl.map "finished"
+
+on property:sys.snapshotctl.unmap=requested
+ exec - root root system -- /system/bin/snapshotctl unmap
+ setprop sys.snapshotctl.unmap "finished"
diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 17d4e31..45dd9b8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -112,6 +112,7 @@
android::base::SetMinimumLogSeverity(android::base::INFO);
std::vector<std::string> modules;
+ std::string modules_load_file;
std::string module_parameters;
std::string mods;
std::vector<std::string> mod_dirs;
@@ -119,7 +120,7 @@
bool blocklist = false;
int rv = EXIT_SUCCESS;
- int opt;
+ int opt, fd;
int option_index = 0;
// NB: We have non-standard short options -l and -D to make it easier for
// OEMs to transition from toybox.
@@ -144,16 +145,19 @@
// is supported here by default, ignore flag if no argument.
check_mode();
if (optarg == NULL) break;
- if (!android::base::ReadFileToString(optarg, &mods)) {
+
+ // Since libmodprobe doesn't fail when the modules load file
+ // doesn't exist, let's check that here so that we don't
+ // silently fail.
+ fd = open(optarg, O_RDONLY | O_CLOEXEC | O_BINARY);
+ if (fd == -1) {
PLOG(ERROR) << "Failed to open " << optarg;
- rv = EXIT_FAILURE;
+ return EXIT_FAILURE;
}
- for (auto mod : android::base::Split(stripComments(mods), "\n")) {
- mod = android::base::Trim(mod);
- if (mod == "") continue;
- if (std::find(modules.begin(), modules.end(), mod) != modules.end()) continue;
- modules.emplace_back(mod);
- }
+ close(fd);
+
+ mod_dirs.emplace_back(android::base::Dirname(optarg));
+ modules_load_file = android::base::Basename(optarg);
break;
case 'b':
blocklist = true;
@@ -233,30 +237,39 @@
LOG(DEBUG) << "mode is " << mode;
LOG(DEBUG) << "mod_dirs is: " << android::base::Join(mod_dirs, " ");
LOG(DEBUG) << "modules is: " << android::base::Join(modules, " ");
+ LOG(DEBUG) << "modules load file is: " << modules_load_file;
LOG(DEBUG) << "module parameters is: " << android::base::Join(module_parameters, " ");
if (modules.empty()) {
if (mode == ListModulesMode) {
// emulate toybox modprobe list with no pattern (list all)
modules.emplace_back("*");
- } else {
+ } else if (modules_load_file.empty()) {
LOG(ERROR) << "No modules given.";
print_usage();
return EXIT_FAILURE;
}
}
- if (parameter_count && modules.size() > 1) {
+ if (parameter_count && (modules.size() > 1 || !modules_load_file.empty())) {
LOG(ERROR) << "Only one module may be loaded when specifying module parameters.";
print_usage();
return EXIT_FAILURE;
}
- Modprobe m(mod_dirs, "modules.load", blocklist);
+ Modprobe m(mod_dirs, modules_load_file.empty() ? "modules.load" : modules_load_file, blocklist);
+ if (mode == AddModulesMode && !modules_load_file.empty()) {
+ if (!m.LoadListedModules(false)) {
+ PLOG(ERROR) << "Failed to load all the modules from " << modules_load_file;
+ return EXIT_FAILURE;
+ }
+ /* Fall-through to load modules provided on the command line (if any)*/
+ }
for (const auto& module : modules) {
switch (mode) {
case AddModulesMode:
if (!m.LoadWithAliases(module, true, module_parameters)) {
+ if (m.IsBlocklisted(module)) continue;
PLOG(ERROR) << "Failed to load module " << module;
rv = EXIT_FAILURE;
}
diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index 66d0876..e2cf57b 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -39,14 +39,17 @@
* repository. They must be kept in sync.
*/
-#define METRICS_PORT "com.android.trusty.metrics"
+#define METRICS_PORT "com.android.trusty.metrics.consumer"
+
+#define UUID_STR_SIZE (37)
/**
* enum metrics_cmd - command identifiers for metrics interface
- * @METRICS_CMD_RESP_BIT: message is a response
- * @METRICS_CMD_REQ_SHIFT: number of bits used by @METRICS_CMD_RESP_BIT
- * @METRICS_CMD_REPORT_EVENT_DROP: report gaps in the event stream
- * @METRICS_CMD_REPORT_CRASH: report an app crash event
+ * @METRICS_CMD_RESP_BIT: message is a response
+ * @METRICS_CMD_REQ_SHIFT: number of bits used by @METRICS_CMD_RESP_BIT
+ * @METRICS_CMD_REPORT_EVENT_DROP: report gaps in the event stream
+ * @METRICS_CMD_REPORT_CRASH: report an app crash event
+ * @METRICS_CMD_REPORT_STORAGE_ERROR: report trusty storage error
*/
enum metrics_cmd {
METRICS_CMD_RESP_BIT = 1,
@@ -54,6 +57,7 @@
METRICS_CMD_REPORT_EVENT_DROP = (1 << METRICS_CMD_REQ_SHIFT),
METRICS_CMD_REPORT_CRASH = (2 << METRICS_CMD_REQ_SHIFT),
+ METRICS_CMD_REPORT_STORAGE_ERROR = (3 << METRICS_CMD_REQ_SHIFT),
};
/**
@@ -90,14 +94,70 @@
/**
* struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
* requests
- * @app_id_len: length of app ID that follows this structure
+ * @app_id: uuid of the app that crashed
+ * @crash_reason: architecture-specific code representing the reason for the
+ * crash
*/
struct metrics_report_crash_req {
- uint32_t app_id_len;
+ char app_id[UUID_STR_SIZE];
+ uint32_t crash_reason;
} __attribute__((__packed__));
-#define METRICS_MAX_APP_ID_LEN 256
+enum TrustyStorageErrorType {
+ TRUSTY_STORAGE_ERROR_UNKNOWN = 0,
+ TRUSTY_STORAGE_ERROR_SUPERBLOCK_INVALID = 1,
+ TRUSTY_STORAGE_ERROR_BLOCK_MAC_MISMATCH = 2,
+ TRUSTY_STORAGE_ERROR_BLOCK_HEADER_INVALID = 3,
+ TRUSTY_STORAGE_ERROR_RPMB_COUNTER_MISMATCH = 4,
+ TRUSTY_STORAGE_ERROR_RPMB_COUNTER_MISMATCH_RECOVERED = 5,
+ TRUSTY_STORAGE_ERROR_RPMB_COUNTER_READ_FAILURE = 6,
+ TRUSTY_STORAGE_ERROR_RPMB_MAC_MISMATCH = 7,
+ TRUSTY_STORAGE_ERROR_RPMB_ADDR_MISMATCH = 8,
+ TRUSTY_STORAGE_ERROR_RPMB_FAILURE_RESPONSE = 9,
+ TRUSTY_STORAGE_ERROR_RPMB_UNKNOWN = 10,
+ TRUSTY_STORAGE_ERROR_RPMB_SCSI_ERROR = 11,
+ TRUSTY_STORAGE_ERROR_IO_ERROR = 12,
+ TRUSTY_STORAGE_ERROR_PROXY_COMMUNICATION_FAILURE = 13,
+};
-#define METRICS_MAX_MSG_SIZE \
- (sizeof(struct metrics_req) + sizeof(struct metrics_report_crash_req) + \
- METRICS_MAX_APP_ID_LEN)
+enum TrustyFileSystem {
+ TRUSTY_FS_UNKNOWN = 0,
+ TRUSTY_FS_TP = 1,
+ TRUSTY_FS_TD = 2,
+ TRUSTY_FS_TDP = 3,
+ TRUSTY_FS_TDEA = 4,
+ TRUSTY_FS_NSP = 5,
+};
+
+enum TrustyBlockType {
+ TRUSTY_BLOCKTYPE_UNKNOWN = 0,
+ TRUSTY_BLOCKTYPE_FILES_ROOT = 1,
+ TRUSTY_BLOCKTYPE_FREE_ROOT = 2,
+ TRUSTY_BLOCKTYPE_FILES_INTERNAL = 3,
+ TRUSTY_BLOCKTYPE_FREE_INTERNAL = 4,
+ TRUSTY_BLOCKTYPE_FILE_ENTRY = 5,
+ TRUSTY_BLOCKTYPE_FILE_BLOCK_MAP = 6,
+ TRUSTY_BLOCKTYPE_FILE_DATA = 7,
+ TRUSTY_BLOCKTYPE_CHECKPOINT_ROOT = 8,
+ TRUSTY_BLOCKTYPE_CHECKPOINT_FILES_ROOT = 9,
+ TRUSTY_BLOCKTYPE_CHECKPOINT_FREE_ROOT = 10,
+};
+
+struct metrics_report_storage_error_req {
+ enum TrustyStorageErrorType error;
+ char app_id[UUID_STR_SIZE];
+ char client_app_id[UUID_STR_SIZE];
+ uint32_t write;
+ enum TrustyFileSystem file_system;
+ uint64_t file_path_hash;
+ enum TrustyBlockType block_type;
+ uint64_t repair_counter;
+} __attribute__((__packed__));
+
+struct metrics_msg {
+ struct metrics_req req;
+ union {
+ struct metrics_report_crash_req crash_args;
+ struct metrics_report_storage_error_req storage_args;
+ };
+} __attribute__((__packed__));
\ No newline at end of file
diff --git a/trusty/metrics/metrics.cpp b/trusty/metrics/metrics.cpp
index 3ac128a..d2f0b0a 100644
--- a/trusty/metrics/metrics.cpp
+++ b/trusty/metrics/metrics.cpp
@@ -78,9 +78,8 @@
return Error() << "connection to Metrics TA has not been initialized yet";
}
- uint8_t msg[METRICS_MAX_MSG_SIZE];
-
- auto rc = read(metrics_fd_, msg, sizeof(msg));
+ struct metrics_msg metrics_msg;
+ int rc = read(metrics_fd_, &metrics_msg, sizeof(metrics_msg));
if (rc < 0) {
return ErrnoError() << "failed to read metrics message";
}
@@ -89,23 +88,14 @@
if (msg_len < sizeof(metrics_req)) {
return Error() << "message too small: " << rc;
}
- auto req = reinterpret_cast<metrics_req*>(msg);
- size_t offset = sizeof(metrics_req);
+ uint32_t cmd = metrics_msg.req.cmd;
uint32_t status = METRICS_NO_ERROR;
- switch (req->cmd) {
+ switch (cmd) {
case METRICS_CMD_REPORT_CRASH: {
- if (msg_len < offset + sizeof(metrics_report_crash_req)) {
- return Error() << "message too small: " << rc;
- }
- auto crash_args = reinterpret_cast<metrics_report_crash_req*>(msg + offset);
- offset += sizeof(metrics_report_crash_req);
-
- if (msg_len < offset + crash_args->app_id_len) {
- return Error() << "message too small: " << rc;
- }
- auto app_id_ptr = reinterpret_cast<char*>(msg + offset);
- std::string app_id(app_id_ptr, crash_args->app_id_len);
+ struct metrics_report_crash_req crash_args = metrics_msg.crash_args;
+ auto app_id_ptr = crash_args.app_id;
+ std::string app_id(app_id_ptr, UUID_STR_SIZE);
HandleCrash(app_id);
break;
@@ -121,7 +111,7 @@
}
metrics_resp resp = {
- .cmd = req->cmd | METRICS_CMD_RESP_BIT,
+ .cmd = cmd | METRICS_CMD_RESP_BIT,
.status = status,
};
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