Merge "Remove VNDK definition(s)" into main
diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 235fdfd..0c5543e 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -240,11 +240,16 @@
"libdebuggerd/backtrace.cpp",
"libdebuggerd/gwp_asan.cpp",
"libdebuggerd/open_files_list.cpp",
+ "libdebuggerd/scudo.cpp",
"libdebuggerd/tombstone.cpp",
"libdebuggerd/tombstone_proto.cpp",
"libdebuggerd/utility.cpp",
],
+ cflags: [
+ "-DUSE_SCUDO",
+ ],
+
local_include_dirs: ["libdebuggerd/include"],
export_include_dirs: ["libdebuggerd/include"],
@@ -256,6 +261,7 @@
"bionic_libc_platform_headers",
"gwp_asan_headers",
"liblog_headers",
+ "scudo_headers",
],
static_libs: [
@@ -273,6 +279,7 @@
"libtombstone_proto",
"libprocinfo",
"libprotobuf-cpp-lite",
+ "libscudo",
],
target: {
@@ -312,11 +319,9 @@
cflags: ["-DROOT_POSSIBLE"],
},
- malloc_not_svelte: {
- cflags: ["-DUSE_SCUDO"],
- whole_static_libs: ["libscudo"],
- srcs: ["libdebuggerd/scudo.cpp"],
- header_libs: ["scudo_headers"],
+ malloc_low_memory: {
+ cflags: ["-UUSE_SCUDO"],
+ exclude_static_libs: ["libscudo"],
},
},
apex_available: [
@@ -373,7 +378,6 @@
sanitize: {
memtag_heap: true,
- memtag_stack: true,
},
shared_libs: [
@@ -448,6 +452,7 @@
header_libs: [
"bionic_libc_platform_headers",
+ "libnative_bridge_support_accessor_headers",
],
static_libs: [
@@ -457,6 +462,8 @@
"libtombstone_proto",
"libprotobuf-cpp-lite",
+
+ "libnative_bridge_guest_state_accessor",
],
shared_libs: [
@@ -472,6 +479,15 @@
// Required for tests.
required: ["crash_dump.policy"],
+
+ target: {
+ android: {
+ header_libs: [
+ "libnative_bridge_support_accessor_headers", // For dlext_namespaces.h
+ ],
+ shared_libs: ["libdl_android"], // For android_get_exported_namespace implementation
+ },
+ },
}
cc_binary {
diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 61d7155..824d20a 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -4,6 +4,10 @@
"name": "debuggerd_test"
},
{
+ "name": "debuggerd_test",
+ "keywords": ["primary-device"]
+ },
+ {
"name": "libtombstoned_client_rust_test"
},
{
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index a23a269..77d4a07 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -25,6 +25,7 @@
#include <sys/wait.h>
#include <unistd.h>
+#include <cstdint>
#include <limits>
#include <map>
#include <memory>
@@ -42,6 +43,7 @@
#include <android-base/unique_fd.h>
#include <bionic/macros.h>
#include <bionic/reserved_signals.h>
+#include <bionic/tls_defines.h>
#include <cutils/sockets.h>
#include <log/log.h>
#include <private/android_filesystem_config.h>
@@ -52,7 +54,18 @@
#include <unwindstack/AndroidUnwinder.h>
#include <unwindstack/Error.h>
+#include <unwindstack/MachineArm.h>
+#include <unwindstack/MachineArm64.h>
+#include <unwindstack/MachineRiscv64.h>
#include <unwindstack/Regs.h>
+#include <unwindstack/RegsArm.h>
+#include <unwindstack/RegsArm64.h>
+#include <unwindstack/RegsRiscv64.h>
+#include <unwindstack/UserArm.h>
+#include <unwindstack/UserArm64.h>
+#include <unwindstack/UserRiscv64.h>
+
+#include <native_bridge_support/guest_state_accessor/accessor.h>
#include "libdebuggerd/backtrace.h"
#include "libdebuggerd/tombstone.h"
@@ -68,6 +81,10 @@
using android::base::StringPrintf;
using android::base::unique_fd;
+// This stores guest architecture. When the architecture is supported, tombstone file will output
+// guest state information.
+static Architecture g_guest_arch;
+
static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
struct stat st;
std::string task_path = StringPrintf("task/%d", tid);
@@ -143,7 +160,7 @@
}
static bool activity_manager_notify(pid_t pid, int signal, const std::string& amfd_data,
- bool recoverable_gwp_asan_crash) {
+ bool recoverable_crash) {
ATRACE_CALL();
android::base::unique_fd amfd(socket_local_client(
"/data/system/ndebugsocket", ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM));
@@ -169,7 +186,7 @@
// Activity Manager protocol:
// - 32-bit network-byte-order: pid
// - 32-bit network-byte-order: signal number
- // - byte: recoverable_gwp_asan_crash
+ // - byte: recoverable_crash
// - bytes: raw text of the dump
// - null terminator
@@ -185,10 +202,9 @@
return false;
}
- uint8_t recoverable_gwp_asan_crash_byte = recoverable_gwp_asan_crash ? 1 : 0;
- if (!android::base::WriteFully(amfd, &recoverable_gwp_asan_crash_byte,
- sizeof(recoverable_gwp_asan_crash_byte))) {
- PLOG(ERROR) << "AM recoverable_gwp_asan_crash_byte write failed";
+ uint8_t recoverable_crash_byte = recoverable_crash ? 1 : 0;
+ if (!android::base::WriteFully(amfd, &recoverable_crash_byte, sizeof(recoverable_crash_byte))) {
+ PLOG(ERROR) << "AM recoverable_crash_byte write failed";
return false;
}
@@ -280,35 +296,34 @@
static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
std::unique_ptr<unwindstack::Regs>* regs, ProcessInfo* process_info,
- bool* recoverable_gwp_asan_crash) {
+ bool* recoverable_crash) {
std::aligned_storage<sizeof(CrashInfo) + 1, alignof(CrashInfo)>::type buf;
CrashInfo* crash_info = reinterpret_cast<CrashInfo*>(&buf);
ssize_t rc = TEMP_FAILURE_RETRY(read(fd.get(), &buf, sizeof(buf)));
- *recoverable_gwp_asan_crash = false;
+ *recoverable_crash = false;
if (rc == -1) {
PLOG(FATAL) << "failed to read target ucontext";
- } else {
- ssize_t expected_size = 0;
- switch (crash_info->header.version) {
- case 1:
- case 2:
- case 3:
- expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataStatic);
- break;
+ }
+ ssize_t expected_size = 0;
+ switch (crash_info->header.version) {
+ case 1:
+ case 2:
+ case 3:
+ expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataStatic);
+ break;
- case 4:
- expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataDynamic);
- break;
+ case 4:
+ expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataDynamic);
+ break;
- default:
- LOG(FATAL) << "unexpected CrashInfo version: " << crash_info->header.version;
- break;
- };
+ default:
+ LOG(FATAL) << "unexpected CrashInfo version: " << crash_info->header.version;
+ break;
+ }
- if (rc < expected_size) {
- LOG(FATAL) << "read " << rc << " bytes when reading target crash information, expected "
- << expected_size;
- }
+ if (rc < expected_size) {
+ LOG(FATAL) << "read " << rc << " bytes when reading target crash information, expected "
+ << expected_size;
}
switch (crash_info->header.version) {
@@ -321,7 +336,7 @@
process_info->scudo_region_info = crash_info->data.d.scudo_region_info;
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;
+ *recoverable_crash = crash_info->data.d.recoverable_crash;
process_info->crash_detail_page = crash_info->data.d.crash_detail_page;
FALLTHROUGH_INTENDED;
case 1:
@@ -404,6 +419,107 @@
sigaction(SIGPIPE, &action, nullptr);
}
+static bool PtracePeek(int request, pid_t tid, uintptr_t addr, void* data, std::string_view err_msg,
+ uintptr_t* result) {
+ errno = 0;
+ *result = ptrace(request, tid, addr, data);
+ if (errno != 0) {
+ PLOG(ERROR) << err_msg;
+ return false;
+ }
+ return true;
+}
+
+static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
+ NativeBridgeGuestRegs* guest_regs) {
+ auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(tid);
+
+ uintptr_t header_ptr = 0;
+ uintptr_t base = 0;
+#if defined(__x86_64__)
+ if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
+ "failed to read thread register for thread " + std::to_string(tid), &base)) {
+ return false;
+ }
+#elif defined(__aarch64__)
+ // base is implicitly casted to uint64_t.
+ struct iovec pt_iov {
+ .iov_base = &base, .iov_len = sizeof(base),
+ };
+
+ if (ptrace(PTRACE_GETREGSET, tid, NT_ARM_TLS, &pt_iov) != 0) {
+ PLOG(ERROR) << "failed to read thread register for thread " << tid;
+ }
+#else
+ // TODO(b/339287219): Add case for Riscv host.
+ return false;
+#endif
+ auto ptr_to_guest_slot = base + TLS_SLOT_NATIVE_BRIDGE_GUEST_STATE * sizeof(uintptr_t);
+ if (!process_memory->ReadFully(ptr_to_guest_slot, &header_ptr, sizeof(uintptr_t))) {
+ PLOG(ERROR) << "failed to get guest state TLS slot content for thread " << tid;
+ return false;
+ }
+
+ NativeBridgeGuestStateHeader header;
+ if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader))) {
+ PLOG(ERROR) << "failed to get the guest state header for thread " << tid;
+ return false;
+ }
+ if (header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
+ // Return when ptr points to unmapped memory or no valid guest state.
+ return false;
+ }
+ auto guest_state_data_copy = std::make_unique<unsigned char[]>(header.guest_state_data_size);
+ if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(header.guest_state_data),
+ guest_state_data_copy.get(), header.guest_state_data_size)) {
+ PLOG(ERROR) << "failed to read the guest state data for thread " << tid;
+ return false;
+ }
+
+ LoadGuestStateRegisters(guest_state_data_copy.get(), header.guest_state_data_size, guest_regs);
+ return true;
+}
+
+static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Regs>* regs,
+ pid_t tid) {
+ // TODO: remove [[maybe_unused]], when the ARM32 case is removed from the native bridge support.
+ NativeBridgeGuestRegs guest_regs;
+ if (!GetGuestRegistersFromCrashedProcess(tid, &guest_regs)) {
+ return;
+ }
+
+ switch (guest_regs.guest_arch) {
+#if defined(__LP64__)
+ case NATIVE_BRIDGE_ARCH_ARM64: {
+ unwindstack::arm64_user_regs arm64_user_regs = {};
+ for (size_t i = 0; i < unwindstack::ARM64_REG_R31; i++) {
+ arm64_user_regs.regs[i] = guest_regs.regs_arm64.x[i];
+ }
+ arm64_user_regs.sp = guest_regs.regs_arm64.sp;
+ arm64_user_regs.pc = guest_regs.regs_arm64.ip;
+ regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
+
+ g_guest_arch = Architecture::ARM64;
+ break;
+ }
+ case NATIVE_BRIDGE_ARCH_RISCV64: {
+ unwindstack::riscv64_user_regs riscv64_user_regs = {};
+ // RISCV64_REG_PC is at the first position.
+ riscv64_user_regs.regs[0] = guest_regs.regs_riscv64.ip;
+ for (size_t i = 1; i < unwindstack::RISCV64_REG_REAL_COUNT; i++) {
+ riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
+ }
+ regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
+
+ g_guest_arch = Architecture::RISCV64;
+ break;
+ }
+#endif
+ default:
+ break;
+ }
+}
+
int main(int argc, char** argv) {
DefuseSignalHandlers();
InstallSigPipeHandler();
@@ -487,7 +603,7 @@
std::map<pid_t, ThreadInfo> thread_info;
siginfo_t siginfo;
std::string error;
- bool recoverable_gwp_asan_crash = false;
+ bool recoverable_crash = false;
{
ATRACE_NAME("ptrace");
@@ -539,8 +655,7 @@
if (thread == g_target_thread) {
// Read the thread's registers along with the rest of the crash info out of the pipe.
- ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info,
- &recoverable_gwp_asan_crash);
+ ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info, &recoverable_crash);
info.siginfo = &siginfo;
info.signo = info.siginfo->si_signo;
@@ -553,6 +668,7 @@
continue;
}
}
+ ReadGuestRegisters(&info.guest_registers, thread);
thread_info[thread] = std::move(info);
}
@@ -662,15 +778,39 @@
{
ATRACE_NAME("engrave_tombstone");
- engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
- g_target_thread, process_info, &open_files, &amfd_data);
+ unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
+ switch (g_guest_arch) {
+ case Architecture::ARM32: {
+ regs_arch = unwindstack::ARCH_ARM;
+ break;
+ }
+ case Architecture::ARM64: {
+ regs_arch = unwindstack::ARCH_ARM64;
+ break;
+ }
+ case Architecture::RISCV64: {
+ regs_arch = unwindstack::ARCH_RISCV64;
+ break;
+ }
+ default: {
+ }
+ }
+ if (regs_arch == unwindstack::ARCH_UNKNOWN) {
+ engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+ g_target_thread, process_info, &open_files, &amfd_data);
+ } else {
+ unwindstack::AndroidRemoteUnwinder guest_unwinder(vm_pid, regs_arch);
+ engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+ g_target_thread, process_info, &open_files, &amfd_data, &g_guest_arch,
+ &guest_unwinder);
+ }
}
}
if (fatal_signal) {
// Don't try to notify ActivityManager if it just crashed, or we might hang until timeout.
if (thread_info[target_process].thread_name != "system_server") {
- activity_manager_notify(target_process, signo, amfd_data, recoverable_gwp_asan_crash);
+ activity_manager_notify(target_process, signo, amfd_data, recoverable_crash);
}
}
diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 3b52776..05143ed 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -202,7 +202,9 @@
fprintf(stderr, " fdsan_file close a file descriptor that's owned by a FILE*\n");
fprintf(stderr, " fdsan_dir close a file descriptor that's owned by a DIR*\n");
fprintf(stderr, " seccomp fail a seccomp check\n");
+#if defined(__LP64__)
fprintf(stderr, " xom read execute-only memory\n");
+#endif
fprintf(stderr, "\n");
fprintf(stderr, " LOG_ALWAYS_FATAL call liblog LOG_ALWAYS_FATAL\n");
fprintf(stderr, " LOG_ALWAYS_FATAL_IF call liblog LOG_ALWAYS_FATAL_IF\n");
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 3135d9e..baddf65 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -332,12 +332,7 @@
std::string result;
ConsumeFd(std::move(output_fd), &result);
-#ifdef __LP64__
- ASSERT_MATCH(result,
- R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x000000000000dead)");
-#else
- ASSERT_MATCH(result, R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x0000dead)");
-#endif
+ ASSERT_MATCH(result, R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x0+dead)");
if (mte_supported()) {
// Test that the default TAGGED_ADDR_CTRL value is set.
@@ -603,15 +598,14 @@
}
__attribute__((noinline)) void mte_illegal_setjmp_helper(jmp_buf& jump_buf) {
- // Because the detection of illegal setjmp is done relative to the SP in setjmp,
- // we need to make sure this stack frame is bigger than the one of setjmp.
- // TODO(fmayer): fix that bug and remove the workaround.
- volatile char buf[1024];
- buf[0] = '1';
+ // 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) {
+TEST_F(CrasherTest, DISABLED_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
@@ -1668,6 +1662,9 @@
std::string result;
ConsumeFd(std::move(output_fd), &result);
+ ASSERT_MATCH(
+ result,
+ R"(signal 6 \(SIGABRT\))");
ASSERT_BACKTRACE_FRAME(result, "abort");
}
@@ -1827,10 +1824,14 @@
"Use After Free, 0 bytes into a 7-byte allocation"},
{/* alloc_size */ 15, /* free_before_access */ true, /* access_offset */ 1,
"Use After Free, 1 byte into a 15-byte allocation"},
- {/* alloc_size */ 4096, /* free_before_access */ false, /* access_offset */ 4098,
- "Buffer Overflow, 2 bytes right of a 4096-byte allocation"},
- {/* alloc_size */ 4096, /* free_before_access */ false, /* access_offset */ -1,
- "Buffer Underflow, 1 byte left of a 4096-byte allocation"},
+ {/* alloc_size */ static_cast<size_t>(getpagesize()), /* free_before_access */ false,
+ /* access_offset */ getpagesize() + 2,
+ android::base::StringPrintf("Buffer Overflow, 2 bytes right of a %d-byte allocation",
+ getpagesize())},
+ {/* alloc_size */ static_cast<size_t>(getpagesize()), /* free_before_access */ false,
+ /* access_offset */ -1,
+ android::base::StringPrintf("Buffer Underflow, 1 byte left of a %d-byte allocation",
+ getpagesize())},
};
INSTANTIATE_TEST_SUITE_P(
@@ -1875,8 +1876,8 @@
StartProcess([&recoverable]() {
const char* env[] = {"GWP_ASAN_SAMPLE_RATE=1", "GWP_ASAN_PROCESS_SAMPLING=1",
"GWP_ASAN_MAX_ALLOCS=40000", nullptr, nullptr};
- if (recoverable) {
- env[3] = "GWP_ASAN_RECOVERABLE=true";
+ if (!recoverable) {
+ env[3] = "GWP_ASAN_RECOVERABLE=false";
}
std::string test_name = ::testing::UnitTest::GetInstance()->current_test_info()->name();
test_name = std::regex_replace(test_name, std::regex("run_gwp_asan_test"),
@@ -2975,30 +2976,34 @@
std::string match_str;
// Verify none.
match_str = android::base::StringPrintf(
- " %s-%s --- 0 1000\\n",
+ " %s-%s --- 0 %x\\n",
format_map_pointer(reinterpret_cast<uintptr_t>(none_map)).c_str(),
- format_map_pointer(reinterpret_cast<uintptr_t>(none_map) + getpagesize() - 1).c_str());
+ format_map_pointer(reinterpret_cast<uintptr_t>(none_map) + getpagesize() - 1).c_str(),
+ getpagesize());
ASSERT_MATCH(result, match_str);
// Verify read-only.
match_str = android::base::StringPrintf(
- " %s-%s r-- 0 1000\\n",
+ " %s-%s r-- 0 %x\\n",
format_map_pointer(reinterpret_cast<uintptr_t>(r_map)).c_str(),
- format_map_pointer(reinterpret_cast<uintptr_t>(r_map) + getpagesize() - 1).c_str());
+ format_map_pointer(reinterpret_cast<uintptr_t>(r_map) + getpagesize() - 1).c_str(),
+ getpagesize());
ASSERT_MATCH(result, match_str);
// Verify write-only.
match_str = android::base::StringPrintf(
- " %s-%s -w- 0 1000\\n",
+ " %s-%s -w- 0 %x\\n",
format_map_pointer(reinterpret_cast<uintptr_t>(w_map)).c_str(),
- format_map_pointer(reinterpret_cast<uintptr_t>(w_map) + getpagesize() - 1).c_str());
+ format_map_pointer(reinterpret_cast<uintptr_t>(w_map) + getpagesize() - 1).c_str(),
+ getpagesize());
ASSERT_MATCH(result, match_str);
// Verify exec-only.
match_str = android::base::StringPrintf(
- " %s-%s --x 0 1000\\n",
+ " %s-%s --x 0 %x\\n",
format_map_pointer(reinterpret_cast<uintptr_t>(x_map)).c_str(),
- format_map_pointer(reinterpret_cast<uintptr_t>(x_map) + getpagesize() - 1).c_str());
+ format_map_pointer(reinterpret_cast<uintptr_t>(x_map) + getpagesize() - 1).c_str(),
+ getpagesize());
ASSERT_MATCH(result, match_str);
// Verify file map with non-zero offset and a name.
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 141723b..e26746b 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -108,7 +108,7 @@
"persist.device_config.memory_safety_native.permissive.process.%s",
getprogname());
// DO NOT REPLACE this with GetBoolProperty. That uses std::string which allocates, so it is
- // not async-safe (and this functiong gets used in a signal handler).
+ // not async-safe, and this function gets used in a signal handler.
return property_parse_bool("persist.sys.mte.permissive") ||
property_parse_bool("persist.device_config.memory_safety_native.permissive.default") ||
property_parse_bool(process_sysprop_name) ||
@@ -275,10 +275,6 @@
}
}
-static pid_t __fork() {
- return clone(nullptr, nullptr, 0, nullptr);
-}
-
// Double-clone, with CLONE_FILES to share the file descriptor table for kcmp validation.
// Returns 0 in the orphaned child, the pid of the orphan in the original process, or -1 on failure.
static void create_vm_process() {
@@ -396,7 +392,7 @@
ASSERT_SAME_OFFSET(scudo_ring_buffer, scudo_ring_buffer);
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(recoverable_crash, recoverable_crash);
ASSERT_SAME_OFFSET(crash_detail_page, crash_detail_page);
#undef ASSERT_SAME_OFFSET
@@ -426,7 +422,7 @@
}
// Don't use fork(2) to avoid calling pthread_atfork handlers.
- pid_t crash_dump_pid = __fork();
+ pid_t crash_dump_pid = _Fork();
if (crash_dump_pid == -1) {
async_safe_format_log(ANDROID_LOG_FATAL, "libc",
"failed to fork in debuggerd signal handler: %s", strerror(errno));
@@ -573,6 +569,7 @@
}
gwp_asan_callbacks_t gwp_asan_callbacks = {};
+ bool recoverable_gwp_asan_crash = false;
if (g_callbacks.get_gwp_asan_callbacks != nullptr) {
// GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
// guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
@@ -587,10 +584,30 @@
gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
- process_info.recoverable_gwp_asan_crash = true;
+ recoverable_gwp_asan_crash = true;
+ process_info.recoverable_crash = true;
}
}
+ if (info->si_signo == SIGSEGV &&
+ (info->si_code == SEGV_MTESERR || info->si_code == SEGV_MTEAERR) && is_permissive_mte()) {
+ process_info.recoverable_crash = true;
+ // If we are in permissive MTE mode, we do not crash, but instead disable MTE on this thread,
+ // and then let the failing instruction be retried. The second time should work (except
+ // if there is another non-MTE fault).
+ int tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
+ if (tagged_addr_ctrl < 0) {
+ fatal_errno("failed to PR_GET_TAGGED_ADDR_CTRL");
+ }
+ tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_NONE;
+ if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) < 0) {
+ fatal_errno("failed to PR_SET_TAGGED_ADDR_CTRL");
+ }
+ async_safe_format_log(ANDROID_LOG_ERROR, "libc",
+ "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING.");
+ pthread_mutex_unlock(&crash_mutex);
+ }
+
// If sival_int is ~0, it means that the fallback handler has been called
// once before and this function is being called again to dump the stack
// of a specific thread. It is possible that the prctl call might return 1,
@@ -602,7 +619,7 @@
// you can only set NO_NEW_PRIVS to 1, and the effect should be at worst a single missing
// ANR trace.
debuggerd_fallback_handler(info, ucontext, process_info.abort_msg);
- if (no_new_privs && process_info.recoverable_gwp_asan_crash) {
+ if (no_new_privs && recoverable_gwp_asan_crash) {
gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
return;
}
@@ -679,29 +696,14 @@
// If the signal is fatal, don't unlock the mutex to prevent other crashing threads from
// starting to dump right before our death.
pthread_mutex_unlock(&crash_mutex);
- } else if (process_info.recoverable_gwp_asan_crash) {
- gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
+ } else if (process_info.recoverable_crash) {
+ if (recoverable_gwp_asan_crash) {
+ gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
+ }
pthread_mutex_unlock(&crash_mutex);
}
#ifdef __aarch64__
- else if (info->si_signo == SIGSEGV &&
- (info->si_code == SEGV_MTESERR || info->si_code == SEGV_MTEAERR) &&
- is_permissive_mte()) {
- // If we are in permissive MTE mode, we do not crash, but instead disable MTE on this thread,
- // and then let the failing instruction be retried. The second time should work (except
- // if there is another non-MTE fault).
- int tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
- if (tagged_addr_ctrl < 0) {
- fatal_errno("failed to PR_GET_TAGGED_ADDR_CTRL");
- }
- tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_NONE;
- if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) < 0) {
- fatal_errno("failed to PR_SET_TAGGED_ADDR_CTRL");
- }
- async_safe_format_log(ANDROID_LOG_ERROR, "libc",
- "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING.");
- pthread_mutex_unlock(&crash_mutex);
- } else if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTEAERR && getppid() == 1) {
+ else if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTEAERR && getppid() == 1) {
// Back channel to init (see system/core/init/service.cpp) to signal that
// this process crashed due to an ASYNC MTE fault and should be considered
// for upgrade to SYNC mode. We are re-using the ART profiler signal, which
@@ -761,18 +763,7 @@
debuggerd_register_handlers(&action);
}
-// When debuggerd's signal handler is the first handler called, it's great at
-// handling the recoverable GWP-ASan mode. For apps, sigchain (from libart) is
-// always the first signal handler, and so the following function is what
-// sigchain must call before processing the signal. This allows for processing
-// of a potentially recoverable GWP-ASan crash. If the signal requires GWP-ASan
-// recovery, then dump a report (via the regular debuggerd hanndler), and patch
-// up the allocator, and allow the process to continue (indicated by returning
-// 'true'). If the crash has nothing to do with GWP-ASan, or recovery isn't
-// possible, return 'false'.
-bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
- if (signal_number != SIGSEGV || !signal_has_si_addr(info)) return false;
-
+bool debuggerd_handle_gwp_asan_signal(int signal_number, siginfo_t* info, void* context) {
if (g_callbacks.get_gwp_asan_callbacks == nullptr) return false;
gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
if (gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery == nullptr ||
@@ -810,3 +801,33 @@
pthread_mutex_unlock(&first_crash_mutex);
return true;
}
+
+// When debuggerd's signal handler is the first handler called, it's great at
+// handling the recoverable GWP-ASan and permissive MTE modes. For apps,
+// sigchain (from libart) is always the first signal handler, and so the
+// following function is what sigchain must call before processing the signal.
+// This allows for processing of a potentially recoverable GWP-ASan or MTE
+// crash. If the signal requires recovery, then dump a report (via the regular
+// debuggerd hanndler), and patch up the allocator (in the case of GWP-ASan) or
+// disable MTE on the thread, and allow the process to continue (indicated by
+// returning 'true'). If the crash has nothing to do with GWP-ASan/MTE, or
+// recovery isn't possible, return 'false'.
+bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
+ if (signal_number != SIGSEGV) return false;
+ if (info->si_code == SEGV_MTEAERR || info->si_code == SEGV_MTESERR) {
+ if (!is_permissive_mte()) return false;
+ // Because permissive MTE disables MTE for the entire thread, we're less
+ // worried about getting a whole bunch of crashes in a row. ActivityManager
+ // doesn't like multiple native crashes for an app in a short period of time
+ // (see the comment about recoverable GWP-ASan in
+ // `debuggerd_handle_gwp_asan_signal`), but that shouldn't happen if MTE is
+ // disabled for the entire thread. This might need to be changed if there's
+ // some low-hanging bug that happens across multiple threads in quick
+ // succession.
+ debuggerd_signal_handler(signal_number, info, context);
+ return true;
+ }
+
+ if (!signal_has_si_addr(info)) return false;
+ return debuggerd_handle_gwp_asan_signal(signal_number, info, context);
+}
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index c18cf6e..954f049 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -47,7 +47,7 @@
const char* scudo_ring_buffer;
size_t scudo_ring_buffer_size;
size_t scudo_stack_depot_size;
- bool recoverable_gwp_asan_crash;
+ bool recoverable_crash;
struct crash_detail_page_t* crash_detail_page;
};
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h b/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
index a506859..89bf5a9 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
@@ -16,6 +16,8 @@
#pragma once
+#if defined(USE_SCUDO)
+
#include "types.h"
#include "utility.h"
@@ -49,3 +51,5 @@
void FillInCause(Cause* cause, const scudo_error_report* report,
unwindstack::AndroidUnwinder* unwinder) const;
};
+
+#endif // USE_SCUDO
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index be999e0..dfdfabd 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -28,6 +28,7 @@
#include <android-base/unique_fd.h>
#include "open_files_list.h"
+#include "tombstone.pb.h"
#include "types.h"
// Forward declarations
@@ -54,14 +55,17 @@
unwindstack::AndroidUnwinder* unwinder,
const std::map<pid_t, ThreadInfo>& thread_info, pid_t target_thread,
const ProcessInfo& process_info, OpenFilesList* open_files,
- std::string* amfd_data);
+ std::string* amfd_data, const Architecture* guest_arch = nullptr,
+ unwindstack::AndroidUnwinder* guest_unwinder = nullptr);
void engrave_tombstone_ucontext(int tombstone_fd, int proto_fd, uint64_t abort_msg_address,
siginfo_t* siginfo, ucontext_t* ucontext);
void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
- const ProcessInfo& process_info, const OpenFilesList* open_files);
+ const ProcessInfo& process_info, const OpenFilesList* open_files,
+ const Architecture* guest_arch,
+ unwindstack::AndroidUnwinder* guest_unwinder);
bool tombstone_proto_to_text(
const Tombstone& tombstone,
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 4d69658..c799f24 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -39,6 +39,8 @@
int signo = 0;
siginfo_t* siginfo = nullptr;
+
+ std::unique_ptr<unwindstack::Regs> guest_registers;
};
// This struct is written into a pipe from inside the crashing process.
diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 3fa3bd0..4ee87c8 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#if defined(USE_SCUDO)
+
#include "libdebuggerd/scudo.h"
#include "libdebuggerd/tombstone.h"
@@ -141,3 +143,5 @@
FillInCause(tombstone->add_causes(), &error_info_.reports[report_num++], unwinder);
}
}
+
+#endif // USE_SCUDO
diff --git a/debuggerd/libdebuggerd/test/dump_memory_test.cpp b/debuggerd/libdebuggerd/test/dump_memory_test.cpp
index 5be145a..dee7b48 100644
--- a/debuggerd/libdebuggerd/test/dump_memory_test.cpp
+++ b/debuggerd/libdebuggerd/test/dump_memory_test.cpp
@@ -20,6 +20,8 @@
#include <string>
#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
#include <gtest/gtest.h>
#include <unwindstack/Memory.h>
@@ -27,61 +29,64 @@
#include "log_fake.h"
-const char g_expected_full_dump[] =
-"\nmemory near r1:\n"
-#if defined(__LP64__)
-" 0000000012345650 0706050403020100 0f0e0d0c0b0a0908 ................\n"
-" 0000000012345660 1716151413121110 1f1e1d1c1b1a1918 ................\n"
-" 0000000012345670 2726252423222120 2f2e2d2c2b2a2928 !\"#$%&'()*+,-./\n"
-" 0000000012345680 3736353433323130 3f3e3d3c3b3a3938 0123456789:;<=>?\n"
-" 0000000012345690 4746454443424140 4f4e4d4c4b4a4948 @ABCDEFGHIJKLMNO\n"
-" 00000000123456a0 5756555453525150 5f5e5d5c5b5a5958 PQRSTUVWXYZ[\\]^_\n"
-" 00000000123456b0 6766656463626160 6f6e6d6c6b6a6968 `abcdefghijklmno\n"
-" 00000000123456c0 7776757473727170 7f7e7d7c7b7a7978 pqrstuvwxyz{|}~.\n"
-" 00000000123456d0 8786858483828180 8f8e8d8c8b8a8988 ................\n"
-" 00000000123456e0 9796959493929190 9f9e9d9c9b9a9998 ................\n"
-" 00000000123456f0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8 ................\n"
-" 0000000012345700 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8 ................\n"
-" 0000000012345710 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8 ................\n"
-" 0000000012345720 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8 ................\n"
-" 0000000012345730 e7e6e5e4e3e2e1e0 efeeedecebeae9e8 ................\n"
-" 0000000012345740 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8 ................\n";
-#else
-" 12345650 03020100 07060504 0b0a0908 0f0e0d0c ................\n"
-" 12345660 13121110 17161514 1b1a1918 1f1e1d1c ................\n"
-" 12345670 23222120 27262524 2b2a2928 2f2e2d2c !\"#$%&'()*+,-./\n"
-" 12345680 33323130 37363534 3b3a3938 3f3e3d3c 0123456789:;<=>?\n"
-" 12345690 43424140 47464544 4b4a4948 4f4e4d4c @ABCDEFGHIJKLMNO\n"
-" 123456a0 53525150 57565554 5b5a5958 5f5e5d5c PQRSTUVWXYZ[\\]^_\n"
-" 123456b0 63626160 67666564 6b6a6968 6f6e6d6c `abcdefghijklmno\n"
-" 123456c0 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{|}~.\n"
-" 123456d0 83828180 87868584 8b8a8988 8f8e8d8c ................\n"
-" 123456e0 93929190 97969594 9b9a9998 9f9e9d9c ................\n"
-" 123456f0 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac ................\n"
-" 12345700 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc ................\n"
-" 12345710 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc ................\n"
-" 12345720 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc ................\n"
-" 12345730 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec ................\n"
-" 12345740 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc ................\n";
-#endif
+std::string GetMemoryString(uintptr_t addr, const std::vector<uint64_t>& data) {
+ // Must be even number of data values.
+ CHECK((data.size() & 1) == 0);
-const char g_expected_partial_dump[] = \
-"\nmemory near pc:\n"
+ std::string str;
+ for (size_t i = 0; i < data.size(); i += 2) {
+ str += " ";
+ std::string ascii_str = "";
+ for (size_t j = 0; j < 2; j++) {
+ for (size_t k = 0; k < 8; k++) {
+ uint8_t c = (data[i + j] >> (k * 8)) & 0xff;
+ if (c >= 0x20 && c < 0x7f) {
+ ascii_str += c;
+ } else {
+ ascii_str += '.';
+ }
+ }
+ }
#if defined(__LP64__)
-" 00000000123455e0 0706050403020100 0f0e0d0c0b0a0908 ................\n"
-" 00000000123455f0 1716151413121110 1f1e1d1c1b1a1918 ................\n"
-" 0000000012345600 2726252423222120 2f2e2d2c2b2a2928 !\"#$%&'()*+,-./\n"
-" 0000000012345610 3736353433323130 3f3e3d3c3b3a3938 0123456789:;<=>?\n"
-" 0000000012345620 4746454443424140 4f4e4d4c4b4a4948 @ABCDEFGHIJKLMNO\n"
-" 0000000012345630 5756555453525150 5f5e5d5c5b5a5958 PQRSTUVWXYZ[\\]^_\n";
+ str += android::base::StringPrintf("%016zx %016zx %016zx ", addr, data[i], data[i + 1]);
#else
-" 123455e0 03020100 07060504 0b0a0908 0f0e0d0c ................\n"
-" 123455f0 13121110 17161514 1b1a1918 1f1e1d1c ................\n"
-" 12345600 23222120 27262524 2b2a2928 2f2e2d2c !\"#$%&'()*+,-./\n"
-" 12345610 33323130 37363534 3b3a3938 3f3e3d3c 0123456789:;<=>?\n"
-" 12345620 43424140 47464544 4b4a4948 4f4e4d4c @ABCDEFGHIJKLMNO\n"
-" 12345630 53525150 57565554 5b5a5958 5f5e5d5c PQRSTUVWXYZ[\\]^_\n";
+ str += android::base::StringPrintf(
+ "%08zx %08zx %08zx %08zx %08zx ", addr, static_cast<uintptr_t>(data[i] & 0xffffffff),
+ static_cast<uintptr_t>(data[i] >> 32), static_cast<uintptr_t>(data[i + 1] & 0xffffffff),
+ static_cast<uintptr_t>(data[i + 1] >> 32));
#endif
+ str += ascii_str + "\n";
+ addr += 0x10;
+ }
+ return str;
+}
+
+const std::vector<uint64_t>& GetDefaultData() {
+ static std::vector<uint64_t> data(
+ {0x0706050403020100UL, 0x0f0e0d0c0b0a0908UL, 0x1716151413121110UL, 0x1f1e1d1c1b1a1918UL,
+ 0x2726252423222120UL, 0x2f2e2d2c2b2a2928UL, 0x3736353433323130UL, 0x3f3e3d3c3b3a3938UL,
+ 0x4746454443424140UL, 0x4f4e4d4c4b4a4948UL, 0x5756555453525150UL, 0x5f5e5d5c5b5a5958UL,
+ 0x6766656463626160UL, 0x6f6e6d6c6b6a6968UL, 0x7776757473727170UL, 0x7f7e7d7c7b7a7978UL,
+ 0x8786858483828180UL, 0x8f8e8d8c8b8a8988UL, 0x9796959493929190UL, 0x9f9e9d9c9b9a9998UL,
+ 0xa7a6a5a4a3a2a1a0UL, 0xafaeadacabaaa9a8UL, 0xb7b6b5b4b3b2b1b0UL, 0xbfbebdbcbbbab9b8UL,
+ 0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL, 0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL,
+ 0xe7e6e5e4e3e2e1e0UL, 0xefeeedecebeae9e8UL, 0xf7f6f5f4f3f2f1f0UL, 0xfffefdfcfbfaf9f8UL});
+ return data;
+}
+
+std::string GetFullDumpString() {
+ std::string str = "\nmemory near r1:\n";
+ str += GetMemoryString(0x12345650U, GetDefaultData());
+ return str;
+}
+
+std::string GetPartialDumpString() {
+ std::string str = "\nmemory near pc:\n";
+ std::vector<uint64_t> data = GetDefaultData();
+ data.resize(12);
+ str += GetMemoryString(0x123455e0U, data);
+ return str;
+}
class MemoryMock : public unwindstack::Memory {
public:
@@ -189,7 +194,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetFullDumpString(), tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -209,7 +214,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetFullDumpString(), tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -228,7 +233,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetFullDumpString(), tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -260,7 +265,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -280,7 +285,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
#if defined(__LP64__)
ASSERT_STREQ("6 DEBUG Bytes read 102, is not a multiple of 8\n", getFakeLogPrint().c_str());
@@ -305,7 +310,7 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+ ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
#if defined(__LP64__)
ASSERT_STREQ("6 DEBUG Bytes read 45, is not a multiple of 8\n"
@@ -331,44 +336,9 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- const char* expected_dump = \
-"\nmemory near r1:\n"
-#if defined(__LP64__)
-" 0000000000001000 0000000000000000 0000000000000000 ................\n"
-" 0000000000001010 0000000000000000 0000000000000000 ................\n"
-" 0000000000001020 0000000000000000 0000000000000000 ................\n"
-" 0000000000001030 0000000000000000 0000000000000000 ................\n"
-" 0000000000001040 0000000000000000 0000000000000000 ................\n"
-" 0000000000001050 0000000000000000 0000000000000000 ................\n"
-" 0000000000001060 0000000000000000 0000000000000000 ................\n"
-" 0000000000001070 0000000000000000 0000000000000000 ................\n"
-" 0000000000001080 0000000000000000 0000000000000000 ................\n"
-" 0000000000001090 0000000000000000 0000000000000000 ................\n"
-" 00000000000010a0 0000000000000000 0000000000000000 ................\n"
-" 00000000000010b0 0000000000000000 0000000000000000 ................\n"
-" 00000000000010c0 0000000000000000 0000000000000000 ................\n"
-" 00000000000010d0 0000000000000000 0000000000000000 ................\n"
-" 00000000000010e0 0000000000000000 0000000000000000 ................\n"
-" 00000000000010f0 0000000000000000 0000000000000000 ................\n";
-#else
-" 00001000 00000000 00000000 00000000 00000000 ................\n"
-" 00001010 00000000 00000000 00000000 00000000 ................\n"
-" 00001020 00000000 00000000 00000000 00000000 ................\n"
-" 00001030 00000000 00000000 00000000 00000000 ................\n"
-" 00001040 00000000 00000000 00000000 00000000 ................\n"
-" 00001050 00000000 00000000 00000000 00000000 ................\n"
-" 00001060 00000000 00000000 00000000 00000000 ................\n"
-" 00001070 00000000 00000000 00000000 00000000 ................\n"
-" 00001080 00000000 00000000 00000000 00000000 ................\n"
-" 00001090 00000000 00000000 00000000 00000000 ................\n"
-" 000010a0 00000000 00000000 00000000 00000000 ................\n"
-" 000010b0 00000000 00000000 00000000 00000000 ................\n"
-" 000010c0 00000000 00000000 00000000 00000000 ................\n"
-" 000010d0 00000000 00000000 00000000 00000000 ................\n"
-" 000010e0 00000000 00000000 00000000 00000000 ................\n"
-" 000010f0 00000000 00000000 00000000 00000000 ................\n";
-#endif
- ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+ std::string expected_dump = "\nmemory near r1:\n";
+ expected_dump += GetMemoryString(0x1000, std::vector<uint64_t>(32, 0UL));
+ ASSERT_EQ(expected_dump, tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -414,61 +384,17 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- const char* expected_dump = \
-"\nmemory near r4:\n"
+ std::string expected_dump = "\nmemory near r4:\n";
+ uintptr_t addr;
#if defined(__aarch64__)
-" 00ffffffffffff00 0706050403020100 0f0e0d0c0b0a0908 ................\n"
-" 00ffffffffffff10 1716151413121110 1f1e1d1c1b1a1918 ................\n"
-" 00ffffffffffff20 2726252423222120 2f2e2d2c2b2a2928 !\"#$%&'()*+,-./\n"
-" 00ffffffffffff30 3736353433323130 3f3e3d3c3b3a3938 0123456789:;<=>?\n"
-" 00ffffffffffff40 4746454443424140 4f4e4d4c4b4a4948 @ABCDEFGHIJKLMNO\n"
-" 00ffffffffffff50 5756555453525150 5f5e5d5c5b5a5958 PQRSTUVWXYZ[\\]^_\n"
-" 00ffffffffffff60 6766656463626160 6f6e6d6c6b6a6968 `abcdefghijklmno\n"
-" 00ffffffffffff70 7776757473727170 7f7e7d7c7b7a7978 pqrstuvwxyz{|}~.\n"
-" 00ffffffffffff80 8786858483828180 8f8e8d8c8b8a8988 ................\n"
-" 00ffffffffffff90 9796959493929190 9f9e9d9c9b9a9998 ................\n"
-" 00ffffffffffffa0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8 ................\n"
-" 00ffffffffffffb0 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8 ................\n"
-" 00ffffffffffffc0 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8 ................\n"
-" 00ffffffffffffd0 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8 ................\n"
-" 00ffffffffffffe0 e7e6e5e4e3e2e1e0 efeeedecebeae9e8 ................\n"
-" 00fffffffffffff0 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8 ................\n";
+ addr = 0x00ffffffffffff00UL;
#elif defined(__LP64__)
-" ffffffffffffff00 0706050403020100 0f0e0d0c0b0a0908 ................\n"
-" ffffffffffffff10 1716151413121110 1f1e1d1c1b1a1918 ................\n"
-" ffffffffffffff20 2726252423222120 2f2e2d2c2b2a2928 !\"#$%&'()*+,-./\n"
-" ffffffffffffff30 3736353433323130 3f3e3d3c3b3a3938 0123456789:;<=>?\n"
-" ffffffffffffff40 4746454443424140 4f4e4d4c4b4a4948 @ABCDEFGHIJKLMNO\n"
-" ffffffffffffff50 5756555453525150 5f5e5d5c5b5a5958 PQRSTUVWXYZ[\\]^_\n"
-" ffffffffffffff60 6766656463626160 6f6e6d6c6b6a6968 `abcdefghijklmno\n"
-" ffffffffffffff70 7776757473727170 7f7e7d7c7b7a7978 pqrstuvwxyz{|}~.\n"
-" ffffffffffffff80 8786858483828180 8f8e8d8c8b8a8988 ................\n"
-" ffffffffffffff90 9796959493929190 9f9e9d9c9b9a9998 ................\n"
-" ffffffffffffffa0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8 ................\n"
-" ffffffffffffffb0 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8 ................\n"
-" ffffffffffffffc0 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8 ................\n"
-" ffffffffffffffd0 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8 ................\n"
-" ffffffffffffffe0 e7e6e5e4e3e2e1e0 efeeedecebeae9e8 ................\n"
-" fffffffffffffff0 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8 ................\n";
+ addr = 0xffffffffffffff00UL;
#else
-" ffffff00 03020100 07060504 0b0a0908 0f0e0d0c ................\n"
-" ffffff10 13121110 17161514 1b1a1918 1f1e1d1c ................\n"
-" ffffff20 23222120 27262524 2b2a2928 2f2e2d2c !\"#$%&'()*+,-./\n"
-" ffffff30 33323130 37363534 3b3a3938 3f3e3d3c 0123456789:;<=>?\n"
-" ffffff40 43424140 47464544 4b4a4948 4f4e4d4c @ABCDEFGHIJKLMNO\n"
-" ffffff50 53525150 57565554 5b5a5958 5f5e5d5c PQRSTUVWXYZ[\\]^_\n"
-" ffffff60 63626160 67666564 6b6a6968 6f6e6d6c `abcdefghijklmno\n"
-" ffffff70 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{|}~.\n"
-" ffffff80 83828180 87868584 8b8a8988 8f8e8d8c ................\n"
-" ffffff90 93929190 97969594 9b9a9998 9f9e9d9c ................\n"
-" ffffffa0 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac ................\n"
-" ffffffb0 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc ................\n"
-" ffffffc0 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc ................\n"
-" ffffffd0 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc ................\n"
-" ffffffe0 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec ................\n"
-" fffffff0 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc ................\n";
+ addr = 0xffffff00UL;
#endif
- ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+ expected_dump += GetMemoryString(addr, GetDefaultData());
+ ASSERT_EQ(expected_dump, tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -490,30 +416,15 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- const char* expected_dump = \
-"\nmemory near r4:\n"
-#if defined(__LP64__)
-R"( 0000000010001000 8786858483828180 8f8e8d8c8b8a8988 ................
- 0000000010001010 9796959493929190 9f9e9d9c9b9a9998 ................
- 0000000010001020 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8 ................
- 0000000010001030 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8 ................
- 0000000010001040 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8 ................
- 0000000010001050 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8 ................
- 0000000010001060 e7e6e5e4e3e2e1e0 efeeedecebeae9e8 ................
- 0000000010001070 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8 ................
-)";
-#else
-R"( 10001000 83828180 87868584 8b8a8988 8f8e8d8c ................
- 10001010 93929190 97969594 9b9a9998 9f9e9d9c ................
- 10001020 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac ................
- 10001030 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc ................
- 10001040 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc ................
- 10001050 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc ................
- 10001060 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec ................
- 10001070 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc ................
-)";
-#endif
- ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+ std::string expected_dump = "\nmemory near r4:\n";
+ expected_dump += GetMemoryString(
+ 0x10000000 + page_size,
+ std::vector<uint64_t>{
+ 0x8786858483828180UL, 0x8f8e8d8c8b8a8988UL, 0x9796959493929190UL, 0x9f9e9d9c9b9a9998UL,
+ 0xa7a6a5a4a3a2a1a0UL, 0xafaeadacabaaa9a8UL, 0xb7b6b5b4b3b2b1b0UL, 0xbfbebdbcbbbab9b8UL,
+ 0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL, 0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL,
+ 0xe7e6e5e4e3e2e1e0UL, 0xefeeedecebeae9e8UL, 0xf7f6f5f4f3f2f1f0UL, 0xfffefdfcfbfaf9f8UL});
+ ASSERT_EQ(expected_dump, tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -535,16 +446,11 @@
std::string tombstone_contents;
ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
- const char* expected_dump = \
-"\nmemory near r4:\n"
-#if defined(__LP64__)
-" 0000000010001000 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8 ................\n"
-" 0000000010001010 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8 ................\n";
-#else
-" 10001000 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc ................\n"
-" 10001010 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc ................\n";
-#endif
- ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+ std::string expected_dump = "\nmemory near r4:\n";
+ expected_dump += GetMemoryString(
+ 0x10000000 + page_size, std::vector<uint64_t>{0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL,
+ 0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL});
+ ASSERT_EQ(expected_dump, tombstone_contents);
// Verify that the log buf is empty, and no error messages.
ASSERT_STREQ("", getFakeLogBuf().c_str());
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 375ed8a..0ce5573 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -76,7 +76,7 @@
threads[target_tid] = ThreadInfo {
.registers = std::move(regs), .uid = uid, .tid = target_tid,
.thread_name = std::move(thread_name), .pid = pid, .command_line = std::move(command_line),
- .selinux_label = std::move(selinux_label), .siginfo = siginfo,
+ .selinux_label = std::move(selinux_label), .siginfo = siginfo, .signo = siginfo->si_signo,
// Only supported on aarch64 for now.
#if defined(__aarch64__)
.tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0),
@@ -125,10 +125,12 @@
unwindstack::AndroidUnwinder* unwinder,
const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
const ProcessInfo& process_info, OpenFilesList* open_files,
- std::string* amfd_data) {
+ std::string* amfd_data, const Architecture* guest_arch,
+ unwindstack::AndroidUnwinder* guest_unwinder) {
// Don't copy log messages to tombstone unless this is a development device.
Tombstone tombstone;
- engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files);
+ engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files,
+ guest_arch, guest_unwinder);
if (proto_fd != -1) {
if (!tombstone.SerializeToFileDescriptor(proto_fd.get())) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 74f9a8c..3e8ab6e 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -203,7 +203,7 @@
}
static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
- const ProcessInfo& process_info, const ThreadInfo& main_thread) {
+ const ProcessInfo& process_info, const ThreadInfo& target_thread) {
#if defined(USE_SCUDO)
ScudoCrashData scudo_crash_data(unwinder->GetProcessMemory().get(), process_info);
if (scudo_crash_data.CrashIsMine()) {
@@ -213,13 +213,13 @@
#endif
GwpAsanCrashData gwp_asan_crash_data(unwinder->GetProcessMemory().get(), process_info,
- main_thread);
+ target_thread);
if (gwp_asan_crash_data.CrashIsMine()) {
gwp_asan_crash_data.AddCauseProtos(tombstone, unwinder);
return;
}
- const siginfo *si = main_thread.siginfo;
+ const siginfo *si = target_thread.siginfo;
auto fault_addr = reinterpret_cast<uint64_t>(si->si_addr);
unwindstack::Maps* maps = unwinder->GetMaps();
@@ -238,14 +238,14 @@
} else if (fault_addr == 0xffff0f60) {
cause = "call to kuser_cmpxchg64";
} else {
- cause = get_stack_overflow_cause(fault_addr, main_thread.registers->sp(), maps);
+ cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
}
} else if (si->si_signo == SIGSEGV && si->si_code == SEGV_ACCERR) {
auto map_info = maps->Find(fault_addr);
if (map_info != nullptr && map_info->flags() == PROT_EXEC) {
cause = "execute-only (no-read) memory access error; likely due to data in .text.";
} else {
- cause = get_stack_overflow_cause(fault_addr, main_thread.registers->sp(), maps);
+ cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
}
} else if (si->si_signo == SIGSYS && si->si_code == SYS_SECCOMP) {
cause = StringPrintf("seccomp prevented call to disallowed %s system call %d", ABI_STRING,
@@ -482,7 +482,8 @@
}
static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
- const ThreadInfo& thread_info, bool memory_dump = false) {
+ const ThreadInfo& thread_info, bool memory_dump = false,
+ unwindstack::AndroidUnwinder* guest_unwinder = nullptr) {
Thread thread;
thread.set_id(thread_info.tid);
@@ -509,6 +510,27 @@
auto& threads = *tombstone->mutable_threads();
threads[thread_info.tid] = thread;
+
+ if (guest_unwinder) {
+ if (!thread_info.guest_registers) {
+ async_safe_format_log(ANDROID_LOG_INFO, LOG_TAG,
+ "No guest state registers information for tid %d", thread_info.tid);
+ return;
+ }
+ Thread guest_thread;
+ unwindstack::AndroidUnwinderData guest_data;
+ guest_data.saved_initial_regs = std::make_optional<std::unique_ptr<unwindstack::Regs>>();
+ if (guest_unwinder->Unwind(thread_info.guest_registers.get(), guest_data)) {
+ dump_thread_backtrace(guest_data.frames, guest_thread);
+ } else {
+ async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+ "Unwind guest state registers failed for tid %d: Error %s",
+ thread_info.tid, guest_data.GetErrorString().c_str());
+ }
+ dump_registers(guest_unwinder, *guest_data.saved_initial_regs, guest_thread, memory_dump);
+ auto& guest_threads = *tombstone->mutable_guest_threads();
+ guest_threads[thread_info.tid] = guest_thread;
+ }
}
static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
@@ -685,28 +707,35 @@
}
void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
- const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
- const ProcessInfo& process_info, const OpenFilesList* open_files) {
+ const std::map<pid_t, ThreadInfo>& threads, pid_t target_tid,
+ const ProcessInfo& process_info, const OpenFilesList* open_files,
+ const Architecture* guest_arch,
+ unwindstack::AndroidUnwinder* guest_unwinder) {
Tombstone result;
result.set_arch(get_arch());
+ if (guest_arch != nullptr) {
+ result.set_guest_arch(*guest_arch);
+ } else {
+ result.set_guest_arch(Architecture::NONE);
+ }
result.set_build_fingerprint(android::base::GetProperty("ro.build.fingerprint", "unknown"));
result.set_revision(android::base::GetProperty("ro.revision", "unknown"));
result.set_timestamp(get_timestamp());
- const ThreadInfo& main_thread = threads.at(target_thread);
- result.set_pid(main_thread.pid);
- result.set_tid(main_thread.tid);
- result.set_uid(main_thread.uid);
- result.set_selinux_label(main_thread.selinux_label);
+ const ThreadInfo& target_thread = threads.at(target_tid);
+ result.set_pid(target_thread.pid);
+ result.set_tid(target_thread.tid);
+ result.set_uid(target_thread.uid);
+ result.set_selinux_label(target_thread.selinux_label);
// The main thread must have a valid siginfo.
- CHECK(main_thread.siginfo != nullptr);
+ CHECK(target_thread.siginfo != nullptr);
struct sysinfo si;
sysinfo(&si);
android::procinfo::ProcessInfo proc_info;
std::string error;
- if (android::procinfo::GetProcessInfo(main_thread.pid, &proc_info, &error)) {
+ if (android::procinfo::GetProcessInfo(target_thread.pid, &proc_info, &error)) {
uint64_t starttime = proc_info.starttime / sysconf(_SC_CLK_TCK);
result.set_process_uptime(si.uptime - starttime);
} else {
@@ -714,25 +743,28 @@
error.c_str());
}
+ result.set_page_size(getpagesize());
+ result.set_has_been_16kb_mode(android::base::GetBoolProperty("ro.misctrl.16kb_before", false));
+
auto cmd_line = result.mutable_command_line();
- for (const auto& arg : main_thread.command_line) {
+ for (const auto& arg : target_thread.command_line) {
*cmd_line->Add() = arg;
}
- if (!main_thread.siginfo) {
+ if (!target_thread.siginfo) {
async_safe_fatal("siginfo missing");
}
Signal sig;
- sig.set_number(main_thread.signo);
- sig.set_name(get_signame(main_thread.siginfo));
- sig.set_code(main_thread.siginfo->si_code);
- sig.set_code_name(get_sigcode(main_thread.siginfo));
+ sig.set_number(target_thread.signo);
+ sig.set_name(get_signame(target_thread.siginfo));
+ sig.set_code(target_thread.siginfo->si_code);
+ sig.set_code_name(get_sigcode(target_thread.siginfo));
- if (signal_has_sender(main_thread.siginfo, main_thread.pid)) {
+ if (signal_has_sender(target_thread.siginfo, target_thread.pid)) {
sig.set_has_sender(true);
- sig.set_sender_uid(main_thread.siginfo->si_uid);
- sig.set_sender_pid(main_thread.siginfo->si_pid);
+ sig.set_sender_uid(target_thread.siginfo->si_uid);
+ sig.set_sender_pid(target_thread.siginfo->si_pid);
}
if (process_info.has_fault_address) {
@@ -746,28 +778,28 @@
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);
+ // Dump the target thread, but save the memory around the registers.
+ dump_thread(&result, unwinder, target_thread, /* memory_dump */ true, guest_unwinder);
for (const auto& [tid, thread_info] : threads) {
- if (tid != target_thread) {
- dump_thread(&result, unwinder, thread_info);
+ if (tid != target_tid) {
+ dump_thread(&result, unwinder, thread_info, /* memory_dump */ false, guest_unwinder);
}
}
- dump_probable_cause(&result, unwinder, process_info, main_thread);
+ dump_probable_cause(&result, unwinder, process_info, target_thread);
dump_mappings(&result, unwinder->GetMaps(), unwinder->GetProcessMemory());
// Only dump logs on debuggable devices.
if (android::base::GetBoolProperty("ro.debuggable", false)) {
// Get the thread that corresponds to the main pid of the process.
- const ThreadInfo& thread = threads.at(main_thread.pid);
+ const ThreadInfo& thread = threads.at(target_thread.pid);
// Do not attempt to dump logs of the logd process because the gathering
// of logs can hang until a timeout occurs.
if (thread.thread_name != "logd") {
- dump_logcat(&result, main_thread.pid);
+ dump_logcat(&result, target_thread.pid);
}
}
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index cefa2d6..1900719 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -79,8 +79,8 @@
return describe_end(value, desc);
}
-static const char* abi_string(const Tombstone& tombstone) {
- switch (tombstone.arch()) {
+static const char* abi_string(const Architecture& arch) {
+ switch (arch) {
case Architecture::ARM32:
return "arm";
case Architecture::ARM64:
@@ -578,14 +578,38 @@
}
}
+static void print_guest_thread(CallbackType callback, const Tombstone& tombstone,
+ const Thread& guest_thread, pid_t tid, bool should_log) {
+ CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
+ CBS("Guest thread information for tid: %d", tid);
+ print_thread_registers(callback, tombstone, guest_thread, should_log);
+
+ CBS("");
+ CB(true, "%d total frames", guest_thread.current_backtrace().size());
+ CB(true, "backtrace:");
+ print_backtrace(callback, tombstone, guest_thread.current_backtrace(), should_log);
+
+ print_thread_memory_dump(callback, tombstone, guest_thread);
+}
+
bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback) {
CBL("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***");
CBL("Build fingerprint: '%s'", tombstone.build_fingerprint().c_str());
CBL("Revision: '%s'", tombstone.revision().c_str());
- CBL("ABI: '%s'", abi_string(tombstone));
+ CBL("ABI: '%s'", abi_string(tombstone.arch()));
+ if (tombstone.guest_arch() != Architecture::NONE) {
+ CBL("Guest architecture: '%s'", abi_string(tombstone.guest_arch()));
+ }
CBL("Timestamp: %s", tombstone.timestamp().c_str());
CBL("Process uptime: %ds", tombstone.process_uptime());
+ // only print this info if the page size is not 4k or has been in 16k mode
+ if (tombstone.page_size() != 4096) {
+ CBL("Page size: %d bytes", tombstone.page_size());
+ } else if (tombstone.has_been_16kb_mode()) {
+ CBL("Has been in 16kb mode: yes");
+ }
+
// Process header
const auto& threads = tombstone.threads();
auto main_thread_it = threads.find(tombstone.tid());
@@ -600,6 +624,12 @@
print_logs(callback, tombstone, 50);
+ const auto& guest_threads = tombstone.guest_threads();
+ auto main_guest_thread_it = guest_threads.find(tombstone.tid());
+ if (main_guest_thread_it != threads.end()) {
+ print_guest_thread(callback, tombstone, main_guest_thread_it->second, tombstone.tid(), true);
+ }
+
// protobuf's map is unordered, so sort the keys first.
std::set<int> thread_ids;
for (const auto& [tid, _] : threads) {
@@ -611,6 +641,10 @@
for (const auto& tid : thread_ids) {
CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
print_thread(callback, tombstone, threads.find(tid)->second);
+ auto guest_thread_it = guest_threads.find(tid);
+ if (guest_thread_it != guest_threads.end()) {
+ print_guest_thread(callback, tombstone, guest_thread_it->second, tid, false);
+ }
}
if (tombstone.open_fds().size() > 0) {
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 214cbfb..6f9cd96 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -22,6 +22,7 @@
message Tombstone {
Architecture arch = 1;
+ Architecture guest_arch = 24;
string build_fingerprint = 2;
string revision = 3;
string timestamp = 4;
@@ -42,11 +43,15 @@
repeated Cause causes = 15;
map<uint32, Thread> threads = 16;
+ map<uint32, Thread> guest_threads = 25;
repeated MemoryMapping memory_mappings = 17;
repeated LogBuffer log_buffers = 18;
repeated FD open_fds = 19;
- reserved 22 to 999;
+ uint32 page_size = 22;
+ bool has_been_16kb_mode = 23;
+
+ reserved 26 to 999;
}
enum Architecture {
@@ -55,8 +60,9 @@
X86 = 2;
X86_64 = 3;
RISCV64 = 4;
+ NONE = 5;
- reserved 5 to 999;
+ reserved 6 to 999;
}
message Signal {
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index d3fc15e..9af7377 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -100,7 +100,7 @@
uintptr_t scudo_ring_buffer;
size_t scudo_ring_buffer_size;
size_t scudo_stack_depot_size;
- bool recoverable_gwp_asan_crash;
+ bool recoverable_crash;
uintptr_t crash_detail_page;
};
diff --git a/debuggerd/test_permissive_mte/AndroidTest.xml b/debuggerd/test_permissive_mte/AndroidTest.xml
index bd3d018..db5f5b8 100644
--- a/debuggerd/test_permissive_mte/AndroidTest.xml
+++ b/debuggerd/test_permissive_mte/AndroidTest.xml
@@ -17,8 +17,6 @@
<option name="test-suite-tag" value="init_test_upgrade_mte" />
<option name="test-suite-tag" value="apct" />
- <!-- For tombstone inspection. -->
- <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer"/>
<target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
<option name="cleanup" value="true" />
<option name="push" value="mte_crash->/data/local/tmp/mte_crash" />
diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index e2a67a2..fa67d46 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -96,7 +96,7 @@
class CrashQueue {
public:
CrashQueue(const std::string& dir_path, const std::string& file_name_prefix, size_t max_artifacts,
- size_t max_concurrent_dumps, bool supports_proto)
+ size_t max_concurrent_dumps, bool supports_proto, bool world_readable)
: file_name_prefix_(file_name_prefix),
dir_path_(dir_path),
dir_fd_(open(dir_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)),
@@ -104,7 +104,8 @@
next_artifact_(0),
max_concurrent_dumps_(max_concurrent_dumps),
num_concurrent_dumps_(0),
- supports_proto_(supports_proto) {
+ supports_proto_(supports_proto),
+ world_readable_(world_readable) {
if (dir_fd_ == -1) {
PLOG(FATAL) << "failed to open directory: " << dir_path;
}
@@ -127,14 +128,16 @@
static CrashQueue* for_tombstones() {
static CrashQueue queue("/data/tombstones", "tombstone_" /* file_name_prefix */,
GetIntProperty("tombstoned.max_tombstone_count", 32),
- 1 /* max_concurrent_dumps */, true /* supports_proto */);
+ 1 /* max_concurrent_dumps */, true /* supports_proto */,
+ true /* world_readable */);
return &queue;
}
static CrashQueue* for_anrs() {
static CrashQueue queue("/data/anr", "trace_" /* file_name_prefix */,
GetIntProperty("tombstoned.max_anr_count", 64),
- 4 /* max_concurrent_dumps */, false /* supports_proto */);
+ 4 /* max_concurrent_dumps */, false /* supports_proto */,
+ false /* world_readable */);
return &queue;
}
@@ -147,10 +150,12 @@
PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
}
- // 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";
+ if (world_readable_) {
+ // 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);
@@ -262,6 +267,7 @@
size_t num_concurrent_dumps_;
bool supports_proto_;
+ bool world_readable_;
std::deque<std::unique_ptr<Crash>> queued_requests_;
@@ -450,6 +456,14 @@
CrashArtifactPaths paths = queue->get_next_artifact_paths();
+ if (crash->output.proto && crash->output.proto->fd != -1) {
+ if (!paths.proto) {
+ LOG(ERROR) << "missing path for proto tombstone";
+ } else {
+ rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
+ }
+ }
+
if (rename_tombstone_fd(crash->output.text.fd, queue->dir_fd(), paths.text)) {
if (crash->crash_type == kDebuggerdJavaBacktrace) {
LOG(ERROR) << "Traces for pid " << crash->crash_pid << " written to: " << paths.text;
@@ -460,14 +474,6 @@
LOG(ERROR) << "Tombstone written to: " << paths.text;
}
}
-
- if (crash->output.proto && crash->output.proto->fd != -1) {
- if (!paths.proto) {
- LOG(ERROR) << "missing path for proto tombstone";
- } else {
- rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
- }
- }
}
static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 12a1ddc..6b9e493 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1547,9 +1547,14 @@
void reboot_to_userspace_fastboot() {
fb->RebootTo("fastboot");
+ if (fb->WaitForDisconnect() != fastboot::SUCCESS) {
+ die("Error waiting for USB disconnect.");
+ }
fb->set_transport(nullptr);
- // Give the current connection time to close.
+ // Not all platforms support WaitForDisconnect. There also isn't a great way to tell whether
+ // or not WaitForDisconnect is supported. So, just wait a bit extra for everyone, in order to
+ // make sure that the device has had time to initiate its reboot and disconnect itself.
std::this_thread::sleep_for(std::chrono::seconds(1));
fb->set_transport(open_device());
diff --git a/fastboot/fuzzer/Android.bp b/fastboot/fuzzer/Android.bp
index a898070..59533fa 100644
--- a/fastboot/fuzzer/Android.bp
+++ b/fastboot/fuzzer/Android.bp
@@ -55,7 +55,10 @@
],
fuzz_config: {
cc: [
- "android-media-fuzzing-reports@google.com",
+ "dvander@google.com",
+ "elsk@google.com",
+ "enh@google.com",
+ "zhangkelvin@google.com",
],
componentid: 533764,
hotlists: [
diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 1989a5c..32e8b88 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -25,8 +25,6 @@
{
"name": "vab_legacy_tests"
},
- // TODO(b/279009697):
- //{"name": "vabc_legacy_tests"},
{
"name": "cow_api_test"
},
@@ -44,8 +42,6 @@
{
"name": "vab_legacy_tests"
},
- // TODO(b/279009697):
- //{"name": "vabc_legacy_tests"}
{
"name": "snapuserd_test"
}
diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 8c0c1ef..835a3e7 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -40,6 +40,7 @@
#include <functional>
#include <map>
#include <memory>
+#include <numeric>
#include <string>
#include <string_view>
#include <thread>
@@ -1553,7 +1554,9 @@
fs_mgr_set_blk_ro(attempted_entry.blk_device, false);
if (!call_vdc({"cryptfs", "encryptFstab", attempted_entry.blk_device,
attempted_entry.mount_point, wiped ? "true" : "false",
- attempted_entry.fs_type, attempted_entry.zoned_device},
+ attempted_entry.fs_type,
+ attempted_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+ android::base::Join(attempted_entry.user_devices, ' ')},
nullptr)) {
LERROR << "Encryption failed";
set_type_property(encryptable);
@@ -1596,7 +1599,9 @@
if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
current_entry.mount_point, "true" /* shouldFormat */,
- current_entry.fs_type, current_entry.zoned_device},
+ current_entry.fs_type,
+ current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+ android::base::Join(current_entry.user_devices, ' ')},
nullptr)) {
LERROR << "Encryption failed";
} else {
@@ -1621,7 +1626,9 @@
if (mount_errno != EBUSY && mount_errno != EACCES &&
should_use_metadata_encryption(attempted_entry)) {
if (!call_vdc({"cryptfs", "mountFstab", attempted_entry.blk_device,
- attempted_entry.mount_point, attempted_entry.zoned_device},
+ attempted_entry.mount_point,
+ current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+ android::base::Join(current_entry.user_devices, ' ')},
nullptr)) {
++error_count;
} else if (current_entry.mount_point == "/data") {
diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 8e76150..0dde1d3 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -125,7 +125,8 @@
}
static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs_projid,
- bool needs_casefold, bool fs_compress, const std::string& zoned_device) {
+ bool needs_casefold, bool fs_compress, bool is_zoned,
+ const std::vector<std::string>& user_devices) {
if (!dev_sz) {
int rc = get_dev_sz(fs_blkdev, &dev_sz);
if (rc) {
@@ -159,16 +160,21 @@
args.push_back(block_size.c_str());
args.push_back("-b");
args.push_back(block_size.c_str());
- if (!zoned_device.empty()) {
- args.push_back("-c");
- args.push_back(zoned_device.c_str());
+
+ if (is_zoned) {
args.push_back("-m");
- args.push_back(fs_blkdev.c_str());
- } else {
- args.push_back(fs_blkdev.c_str());
- args.push_back(size_str.c_str());
+ }
+ for (auto& device : user_devices) {
+ args.push_back("-c");
+ args.push_back(device.c_str());
}
+ if (user_devices.empty()) {
+ args.push_back(fs_blkdev.c_str());
+ args.push_back(size_str.c_str());
+ } else {
+ args.push_back(fs_blkdev.c_str());
+ }
return logwrap_fork_execvp(args.size(), args.data(), nullptr, false, LOG_KLOG, false, nullptr);
}
@@ -184,7 +190,8 @@
if (entry.fs_type == "f2fs") {
return format_f2fs(entry.blk_device, entry.length, needs_projid, needs_casefold,
- entry.fs_mgr_flags.fs_compress, entry.zoned_device);
+ entry.fs_mgr_flags.fs_compress, entry.fs_mgr_flags.is_zoned,
+ entry.user_devices);
} else if (entry.fs_type == "ext4") {
return format_ext4(entry.blk_device, entry.mount_point, needs_projid,
entry.fs_mgr_flags.ext_meta_csum);
diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index 5cc0346..c3ca758 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -71,6 +71,9 @@
"libbase",
"liblog",
],
+ header_libs: [
+ "libstorage_literals_headers",
+ ],
srcs: [":libdm_test_srcs"],
auto_gen_config: true,
require_root: true,
diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index e261aa3..a963322 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -39,6 +39,9 @@
#ifndef DM_DEFERRED_REMOVE
#define DM_DEFERRED_REMOVE (1 << 17)
#endif
+#ifndef DM_IMA_MEASUREMENT_FLAG
+#define DM_IMA_MEASUREMENT_FLAG (1 << 19)
+#endif
namespace android {
namespace dm {
@@ -540,6 +543,10 @@
return GetTable(name, 0, table);
}
+bool DeviceMapper::GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) {
+ return GetTable(name, DM_IMA_MEASUREMENT_FLAG, table);
+}
+
bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) {
return GetTable(name, DM_STATUS_TABLE_FLAG, table);
}
@@ -762,5 +769,25 @@
return true;
}
+bool DeviceMapper::SendMessage(const std::string& name, uint64_t sector,
+ const std::string& message) {
+ std::string ioctl_buffer(sizeof(struct dm_ioctl) + sizeof(struct dm_target_msg), 0);
+ ioctl_buffer += message;
+ ioctl_buffer.push_back('\0');
+
+ struct dm_ioctl* io = reinterpret_cast<struct dm_ioctl*>(&ioctl_buffer[0]);
+ InitIo(io, name);
+ io->data_size = ioctl_buffer.size();
+ io->data_start = sizeof(struct dm_ioctl);
+ struct dm_target_msg* msg =
+ reinterpret_cast<struct dm_target_msg*>(&ioctl_buffer[sizeof(struct dm_ioctl)]);
+ msg->sector = sector;
+ if (ioctl(fd_, DM_TARGET_MSG, io)) {
+ PLOG(ERROR) << "DM_TARGET_MSG failed";
+ return false;
+ }
+ return true;
+}
+
} // namespace dm
} // namespace android
diff --git a/fs_mgr/libdm/dm_target.cpp b/fs_mgr/libdm/dm_target.cpp
index 1f6bd1a..b5cc9aa 100644
--- a/fs_mgr/libdm/dm_target.cpp
+++ b/fs_mgr/libdm/dm_target.cpp
@@ -298,5 +298,43 @@
return android::base::Join(argv, " ");
}
+DmTargetThinPool::DmTargetThinPool(uint64_t start, uint64_t length, const std::string& metadata_dev,
+ const std::string& data_dev, uint64_t data_block_size,
+ uint64_t low_water_mark)
+ : DmTarget(start, length),
+ metadata_dev_(metadata_dev),
+ data_dev_(data_dev),
+ data_block_size_(data_block_size),
+ low_water_mark_(low_water_mark) {}
+
+std::string DmTargetThinPool::GetParameterString() const {
+ std::vector<std::string> args{
+ metadata_dev_,
+ data_dev_,
+ std::to_string(data_block_size_),
+ std::to_string(low_water_mark_),
+ };
+ return android::base::Join(args, " ");
+}
+
+bool DmTargetThinPool::Valid() const {
+ // data_block_size: must be between 128 (64KB) and 2097152 (1GB) and a multiple of 128 (64KB)
+ if (data_block_size_ < 128 || data_block_size_ > 2097152) return false;
+ if (data_block_size_ % 128) return false;
+ return true;
+}
+
+DmTargetThin::DmTargetThin(uint64_t start, uint64_t length, const std::string& pool_dev,
+ uint64_t dev_id)
+ : DmTarget(start, length), pool_dev_(pool_dev), dev_id_(dev_id) {}
+
+std::string DmTargetThin::GetParameterString() const {
+ std::vector<std::string> args{
+ pool_dev_,
+ std::to_string(dev_id_),
+ };
+ return android::base::Join(args, " ");
+}
+
} // namespace dm
} // namespace android
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index d043be6..b890f47 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -37,12 +37,14 @@
#include <gtest/gtest.h>
#include <libdm/dm.h>
#include <libdm/loop_control.h>
+#include <storage_literals/storage_literals.h>
#include "test_util.h"
#include "utility.h"
using namespace std;
using namespace std::chrono_literals;
using namespace android::dm;
+using namespace android::storage_literals;
using android::base::make_scope_guard;
using android::base::unique_fd;
@@ -773,3 +775,42 @@
ASSERT_EQ(name, test_name_);
ASSERT_FALSE(uuid.empty());
}
+
+TEST_F(DmTest, ThinProvisioning) {
+ if (!DeviceMapper::Instance().GetTargetByName("thin-pool", nullptr)) GTEST_SKIP();
+
+ constexpr uint64_t MetaSize = 2_MiB;
+ constexpr uint64_t DataSize = 64_MiB;
+ constexpr uint64_t ThinSize = 1_TiB;
+
+ // Prepare two loop devices for meta and data devices.
+ TemporaryFile meta;
+ ASSERT_GE(meta.fd, 0);
+ ASSERT_EQ(0, ftruncate64(meta.fd, MetaSize));
+ TemporaryFile data;
+ ASSERT_GE(data.fd, 0);
+ ASSERT_EQ(0, ftruncate64(data.fd, DataSize));
+
+ LoopDevice loop_meta(meta.fd, 10s);
+ ASSERT_TRUE(loop_meta.valid());
+ LoopDevice loop_data(data.fd, 10s);
+ ASSERT_TRUE(loop_data.valid());
+
+ // Create a thin-pool
+ DmTable poolTable;
+ poolTable.Emplace<DmTargetThinPool>(0, DataSize / kSectorSize, loop_meta.device(),
+ loop_data.device(), 128, 0);
+ TempDevice pool("pool", poolTable);
+ ASSERT_TRUE(pool.valid());
+
+ // Create a thin volume
+ uint64_t thin_volume_id = 0;
+ ASSERT_TRUE(DeviceMapper::Instance().SendMessage(
+ "pool", 0, "create_thin " + std::to_string(thin_volume_id)));
+
+ // Use a thin volume to create a 1T device
+ DmTable thinTable;
+ thinTable.Emplace<DmTargetThin>(0, ThinSize / kSectorSize, pool.path(), thin_volume_id);
+ TempDevice thin("thin", thinTable);
+ ASSERT_TRUE(thin.valid());
+}
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index 22c475f..43d84f9 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -78,6 +78,7 @@
virtual bool LoadTable(const std::string& name, const DmTable& table) = 0;
virtual bool GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) = 0;
virtual bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) = 0;
+ virtual bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) = 0;
virtual bool GetDmDevicePathByName(const std::string& name, std::string* path) = 0;
virtual bool GetDeviceString(const std::string& name, std::string* dev) = 0;
virtual bool DeleteDeviceIfExists(const std::string& name) = 0;
@@ -267,6 +268,12 @@
// false.
bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) override;
+ // Query the status of a table, given a device name. The output vector will
+ // contain IMA TargetInfo for each target in the table. If the device does
+ // not exist, or there were too many targets, the call will fail and return
+ // false.
+ bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) override;
+
// Identical to GetTableStatus, except also retrives the active table for the device
// mapper device from the kernel.
bool GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) override;
@@ -300,6 +307,9 @@
bool GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid);
+ // Send |message| to target, pointed by |name| and |sector|. Use 0 if |sector| is not needed.
+ bool SendMessage(const std::string& name, uint64_t sector, const std::string& message);
+
private:
// Maximum possible device mapper targets registered in the kernel.
// This is only used to read the list of targets from kernel so we allocate
diff --git a/fs_mgr/libdm/include/libdm/dm_target.h b/fs_mgr/libdm/include/libdm/dm_target.h
index 97f3c13..c49fc5e 100644
--- a/fs_mgr/libdm/include/libdm/dm_target.h
+++ b/fs_mgr/libdm/include/libdm/dm_target.h
@@ -349,6 +349,35 @@
std::string GetParameterString() const override { return ""; }
};
+class DmTargetThinPool final : public DmTarget {
+ public:
+ DmTargetThinPool(uint64_t start, uint64_t length, const std::string& metadata_dev,
+ const std::string& data_dev, uint64_t data_block_size,
+ uint64_t low_water_mark);
+
+ std::string name() const override { return "thin-pool"; }
+ std::string GetParameterString() const override;
+ bool Valid() const override;
+
+ private:
+ std::string metadata_dev_;
+ std::string data_dev_;
+ uint64_t data_block_size_;
+ uint64_t low_water_mark_;
+};
+
+class DmTargetThin final : public DmTarget {
+ public:
+ DmTargetThin(uint64_t start, uint64_t length, const std::string& pool_dev, uint64_t dev_id);
+
+ std::string name() const override { return "thin"; }
+ std::string GetParameterString() const override;
+
+ private:
+ std::string pool_dev_;
+ uint64_t dev_id_;
+};
+
} // namespace dm
} // namespace android
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 6fa22fe..f00e0dc 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -147,6 +147,29 @@
entry->fs_options = std::move(fs_options);
}
+void ParseUserDevices(const std::string& arg, FstabEntry* entry) {
+ auto param = Split(arg, ":");
+ if (param.size() != 2) {
+ LWARNING << "Warning: device= malformed: " << arg;
+ return;
+ }
+
+ if (access(param[1].c_str(), F_OK) != 0) {
+ LWARNING << "Warning: device does not exist : " << param[1];
+ return;
+ }
+
+ if (param[0] == "zoned") {
+ // atgc in f2fs does not support a zoned device
+ auto options = Split(entry->fs_options, ",");
+ options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
+ entry->fs_options = android::base::Join(options, ",");
+ LINFO << "Removed ATGC in fs_options as " << entry->fs_options << " for zoned device";
+ entry->fs_mgr_flags.is_zoned = true;
+ }
+ entry->user_devices.push_back(param[1]);
+}
+
bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
for (const auto& flag : Split(flags, ",")) {
if (flag.empty() || flag == "defaults") continue;
@@ -311,17 +334,8 @@
if (!ParseByteCount(arg, &entry->zram_backingdev_size)) {
LWARNING << "Warning: zram_backingdev_size= flag malformed: " << arg;
}
- } else if (flag == "zoned_device") {
- if (access("/dev/block/by-name/zoned_device", F_OK) == 0) {
- entry->zoned_device = "/dev/block/by-name/zoned_device";
-
- // atgc in f2fs does not support a zoned device
- auto options = Split(entry->fs_options, ",");
- options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
- entry->fs_options = android::base::Join(options, ",");
- LINFO << "Removed ATGC in fs_options as " << entry->fs_options
- << " for zoned device=" << entry->zoned_device;
- }
+ } else if (StartsWith(flag, "device=")) {
+ ParseUserDevices(arg, entry);
} else {
LWARNING << "Warning: unknown flag: " << flag;
}
@@ -849,6 +863,14 @@
[&path](const FstabEntry& entry) { return entry.mount_point == path; });
}
+FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string_view path,
+ const std::string_view fstype) {
+ auto&& vec = GetEntriesByPred(fstab, [&path, fstype](const FstabEntry& entry) {
+ return entry.mount_point == path && entry.fs_type == fstype;
+ });
+ return vec.empty() ? nullptr : vec.front();
+}
+
std::vector<const FstabEntry*> GetEntriesForMountPoint(const Fstab* fstab,
const std::string& path) {
return GetEntriesByPred(fstab,
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 5e4019c..1696daf 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -32,7 +32,7 @@
struct FstabEntry {
std::string blk_device;
- std::string zoned_device;
+ std::vector<std::string> user_devices;
std::string logical_partition_name;
std::string mount_point;
std::string fs_type;
@@ -85,6 +85,7 @@
bool ext_meta_csum : 1;
bool fs_compress : 1;
bool overlayfs_remove_missing_lowerdir : 1;
+ bool is_zoned : 1;
} fs_mgr_flags = {};
bool is_encryptable() const { return fs_mgr_flags.crypt; }
@@ -108,6 +109,9 @@
FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string& path);
const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& path);
+FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string_view path,
+ const std::string_view fstype);
+
// This method builds DSU fstab entries and transfer the fstab.
//
// fstab points to the unmodified fstab.
diff --git a/fs_mgr/liblp/fuzzer/Android.bp b/fs_mgr/liblp/fuzzer/Android.bp
index a9e3509..46bd031 100644
--- a/fs_mgr/liblp/fuzzer/Android.bp
+++ b/fs_mgr/liblp/fuzzer/Android.bp
@@ -15,6 +15,10 @@
*
*/
+package {
+ default_team: "trendy_team_android_kernel",
+}
+
cc_defaults {
name: "liblp_fuzz_defaults",
header_libs: [
@@ -33,7 +37,7 @@
],
fuzz_config: {
cc: [
- "android-media-fuzzing-reports@google.com",
+ "android-systems-storage@google.com",
],
componentid: 59148,
hotlists: ["4593311"],
@@ -41,8 +45,8 @@
vector: "local_no_privileges_required",
service_privilege: "privileged",
users: "multi_user",
- fuzzed_code_usage: "shipped"
- }
+ fuzzed_code_usage: "shipped",
+ },
}
cc_fuzz {
@@ -196,6 +200,6 @@
":test_vendor_boot_v4_with_frag",
],
cflags: [
- "-Wno-unused-parameter",
- ],
+ "-Wno-unused-parameter",
+ ],
}
diff --git a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
index 7f09ac8..162c9fc 100644
--- a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
@@ -28,7 +28,7 @@
static constexpr uint64_t kBlockDeviceInfoSize = 1024 * 1024;
static constexpr uint64_t kValidBlockDeviceInfoSize = 8_GiB;
static constexpr uint64_t kValidMaxGroupSize = 40960;
-static constexpr uint64_t kMinBlockDevValue = 0;
+static constexpr uint64_t kMinBlockDevValue = 1;
static constexpr uint64_t kMaxBlockDevValue = 100000;
static constexpr uint64_t kMinSectorValue = 1;
static constexpr uint64_t kMaxSectorValue = 1000000;
@@ -149,12 +149,16 @@
void BuilderFuzzer::setupBuilder(string superBlockDeviceName) {
uint64_t blockDeviceInfoSize =
- mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kValidBlockDeviceInfoSize;
+ mFdp.ConsumeBool()
+ ? mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue)
+ : kValidBlockDeviceInfoSize;
uint32_t alignment = mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignment;
uint32_t alignmentOffset =
mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignmentOffset;
- uint32_t logicalBlockSize =
- mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidLogicalBlockSize;
+ uint32_t logicalBlockSize = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint32_t>(
+ kMinBlockDevValue, kMaxBlockDevValue)
+ : kValidLogicalBlockSize;
+
BlockDeviceInfo super(superBlockDeviceName, blockDeviceInfoSize, alignment, alignmentOffset,
logicalBlockSize);
mBlockDevices.push_back(super);
@@ -176,13 +180,16 @@
mFdp.ConsumeBool() ? kDeviceInfoName : mFdp.ConsumeRandomLengthString(kMaxBytes);
BlockDeviceInfo changePartitionDeviceInfo(
changePartitionDeviceInfoName,
- mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kBlockDeviceInfoSize /* size */,
+ mFdp.ConsumeBool()
+ ? mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue)
+ : kBlockDeviceInfoSize /* size */,
mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
: kZeroAlignmentOffset /* alignment */,
mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
: kZeroAlignmentOffset /* alignment_offset */,
- mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
- : kValidLogicalBlockSize /* logical_block_size */);
+ mFdp.ConsumeBool()
+ ? mFdp.ConsumeIntegralInRange<uint32_t>(kMinBlockDevValue, kMaxBlockDevValue)
+ : kValidLogicalBlockSize);
mBlockDevices.push_back(changePartitionDeviceInfo);
}
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 5ceaf28..914b4a6 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -322,24 +322,6 @@
}
cc_test {
- name: "vabc_legacy_tests",
- defaults: [
- "libsnapshot_test_defaults",
- "libsnapshot_hal_deps",
- ],
- cppflags: [
- "-DLIBSNAPSHOT_TEST_VABC_LEGACY",
- ],
- test_suites: [
- "device-tests",
- ],
- test_options: {
- // Legacy VABC launched in Android S.
- min_shipping_api_level: 31,
- },
-}
-
-cc_test {
name: "vts_ota_config_test",
srcs: [
"vts_ota_config_test.cpp",
diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index f2f7fc1..076a918 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -212,6 +212,9 @@
// io_uring support
bool io_uring_enabled = 10;
+
+ // legacy dm-snapshot based snapuserd
+ bool legacy_snapuserd = 11;
}
// Next: 10
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index ac04245..21dc666 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,7 +17,6 @@
#pragma once
#include <memory>
-#include <vector>
#include "libsnapshot/cow_format.h"
namespace android {
@@ -25,27 +24,30 @@
class ICompressor {
public:
- explicit ICompressor(uint32_t compression_level, uint32_t block_size)
+ explicit ICompressor(const int32_t compression_level, const uint32_t block_size)
: compression_level_(compression_level), block_size_(block_size) {}
virtual ~ICompressor() {}
// Factory methods for compression methods.
- static std::unique_ptr<ICompressor> Gz(uint32_t compression_level, const int32_t block_size);
- static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level,
- const int32_t block_size);
- static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level, const int32_t block_size);
- static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t block_size);
+ static std::unique_ptr<ICompressor> Gz(const int32_t compression_level,
+ const uint32_t block_size);
+ static std::unique_ptr<ICompressor> Brotli(const int32_t compression_level,
+ const uint32_t block_size);
+ static std::unique_ptr<ICompressor> Lz4(const int32_t compression_level,
+ const uint32_t block_size);
+ static std::unique_ptr<ICompressor> Zstd(const int32_t compression_level,
+ const uint32_t block_size);
static std::unique_ptr<ICompressor> Create(CowCompression compression,
- const int32_t block_size);
+ const uint32_t block_size);
- uint32_t GetCompressionLevel() const { return compression_level_; }
+ int32_t GetCompressionLevel() const { return compression_level_; }
uint32_t GetBlockSize() const { return block_size_; }
[[nodiscard]] virtual std::vector<uint8_t> Compress(const void* data, size_t length) const = 0;
private:
- uint32_t compression_level_;
- uint32_t block_size_;
+ const int32_t compression_level_;
+ const uint32_t block_size_;
};
} // namespace snapshot
} // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 6865b19..991e17c 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -31,15 +31,9 @@
static constexpr uint32_t kCowVersionMajor = 2;
static constexpr uint32_t kCowVersionMinor = 0;
-static constexpr uint32_t kCowVersionManifest = 2;
-
static constexpr uint32_t kMinCowVersion = 1;
static constexpr uint32_t kMaxCowVersion = 3;
-// Normally, this should be kMaxCowVersion. When a new version is under testing
-// it may be the previous value of kMaxCowVersion.
-static constexpr uint32_t kDefaultCowVersion = 2;
-
// This header appears as the first sequence of bytes in the COW. All fields
// in the layout are little-endian encoded. The on-disk layout is:
//
@@ -293,7 +287,7 @@
};
struct CowCompression {
CowCompressionAlgorithm algorithm = kCowCompressNone;
- uint32_t compression_level = 0;
+ int32_t compression_level = 0;
};
static constexpr uint8_t kCowReadAheadNotStarted = 0;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 651083f..2c6eefb 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -45,7 +45,7 @@
std::optional<uint64_t> max_blocks;
// Number of CowOperations in a cluster. 0 for no clustering. Cannot be 1.
- uint32_t cluster_ops = 200;
+ uint32_t cluster_ops = 1024;
bool scratch_space = true;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index d102863..3ccc3db 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -829,6 +829,9 @@
// Set read-ahead size during OTA
void SetReadAheadSize(const std::string& entry_block_device, off64_t size_kb);
+ // Returns true post OTA reboot if legacy snapuserd is required
+ bool IsLegacySnapuserdPostReboot();
+
android::dm::IDeviceMapper& dm_;
std::unique_ptr<IDeviceInfo> device_;
std::string metadata_dir_;
@@ -839,6 +842,7 @@
std::unique_ptr<SnapuserdClient> snapuserd_client_;
std::unique_ptr<LpMetadata> old_partition_metadata_;
std::optional<bool> is_snapshot_userspace_;
+ std::optional<bool> is_legacy_snapuserd_;
};
} // namespace snapshot
diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 5e9f049..90813fe 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -155,6 +155,9 @@
virtual bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) {
return impl_.GetTableStatus(name, table);
}
+ virtual bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) {
+ return impl_.GetTableStatusIma(name, table);
+ }
virtual bool GetDmDevicePathByName(const std::string& name, std::string* path) {
return impl_.GetDmDevicePathByName(name, path);
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 0205f50..bff5257 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -17,6 +17,7 @@
#include <sys/types.h>
#include <unistd.h>
+#include <cstdint>
#include <limits>
#include <memory>
#include <queue>
@@ -57,7 +58,7 @@
}
std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression,
- const int32_t block_size) {
+ const uint32_t block_size) {
switch (compression.algorithm) {
case kCowCompressLz4:
return ICompressor::Lz4(compression.compression_level, block_size);
@@ -101,7 +102,7 @@
class GzCompressor final : public ICompressor {
public:
- GzCompressor(uint32_t compression_level, const uint32_t block_size)
+ GzCompressor(int32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -122,7 +123,7 @@
class Lz4Compressor final : public ICompressor {
public:
- Lz4Compressor(uint32_t compression_level, const uint32_t block_size)
+ Lz4Compressor(int32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -154,7 +155,7 @@
class BrotliCompressor final : public ICompressor {
public:
- BrotliCompressor(uint32_t compression_level, const uint32_t block_size)
+ BrotliCompressor(int32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -180,7 +181,7 @@
class ZstdCompressor final : public ICompressor {
public:
- ZstdCompressor(uint32_t compression_level, const uint32_t block_size)
+ ZstdCompressor(int32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size),
zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);
@@ -318,22 +319,23 @@
}
}
-std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level,
- const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Brotli(const int32_t compression_level,
+ const uint32_t block_size) {
return std::make_unique<BrotliCompressor>(compression_level, block_size);
}
-std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level, const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Gz(const int32_t compression_level,
+ const uint32_t block_size) {
return std::make_unique<GzCompressor>(compression_level, block_size);
}
-std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level,
- const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Lz4(const int32_t compression_level,
+ const uint32_t block_size) {
return std::make_unique<Lz4Compressor>(compression_level, block_size);
}
-std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level,
- const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Zstd(const int32_t compression_level,
+ const uint32_t block_size) {
return std::make_unique<ZstdCompressor>(compression_level, block_size);
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
index 10cb06d..f00f236 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
@@ -184,7 +184,7 @@
unique_fd cow_fd(dup(cow_->fd));
ASSERT_GE(cow_fd, 0);
- auto writer = CreateCowWriter(kDefaultCowVersion, options, std::move(cow_fd));
+ auto writer = CreateCowWriter(2, options, std::move(cow_fd));
ASSERT_NO_FATAL_FAILURE(WriteCow(writer.get()));
ASSERT_NO_FATAL_FAILURE(TestReads(writer.get()));
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 2021348..4456b26 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -209,6 +209,48 @@
ASSERT_EQ(sink, data);
}
+TEST_F(CowTestV3, BigReplaceOp) {
+ CowOptions options;
+ options.op_count_max = 10000;
+ options.batch_write = true;
+ options.cluster_ops = 2048;
+
+ auto writer = CreateCowWriter(3, options, GetCowFd());
+ std::string data = "This is some data, believe it";
+ data.resize(options.block_size * 4096, '\0');
+ for (int i = 0; i < data.size(); i++) {
+ data[i] = static_cast<char>('A' + i / options.block_size);
+ }
+ ASSERT_TRUE(writer->AddRawBlocks(5, data.data(), data.size()));
+ ASSERT_TRUE(writer->Finalize());
+
+ CowReader reader;
+ ASSERT_TRUE(reader.Parse(cow_->fd));
+
+ const auto& header = reader.header_v3();
+ ASSERT_EQ(header.op_count, 4096);
+
+ auto iter = reader.GetOpIter();
+ ASSERT_NE(iter, nullptr);
+ ASSERT_FALSE(iter->AtEnd());
+
+ size_t i = 0;
+
+ while (!iter->AtEnd()) {
+ auto op = iter->Get();
+ std::string sink(options.block_size, '\0');
+ ASSERT_EQ(op->type(), kCowReplaceOp);
+ ASSERT_EQ(op->data_length, options.block_size);
+ ASSERT_EQ(op->new_block, 5 + i);
+ ASSERT_TRUE(ReadData(reader, op, sink.data(), options.block_size));
+ ASSERT_EQ(std::string_view(sink),
+ std::string_view(data).substr(i * options.block_size, options.block_size))
+ << " readback data for " << i << "th block does not match";
+ iter->Next();
+ i++;
+ }
+}
+
TEST_F(CowTestV3, ConsecutiveReplaceOp) {
CowOptions options;
options.op_count_max = 20;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index d0864e0..0993dba 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -134,7 +134,7 @@
return false;
}
if (parts.size() > 1) {
- if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+ if (!android::base::ParseInt(parts[1], &compression_.compression_level)) {
LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
return false;
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index de2e528..1117ec9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -149,7 +149,7 @@
}
if (parts.size() > 1) {
- if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+ if (!android::base::ParseInt(parts[1], &compression_.compression_level)) {
LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
return false;
}
@@ -173,7 +173,7 @@
batch_size_ = std::max<size_t>(options_.cluster_ops, 1);
data_vec_.reserve(batch_size_);
cached_data_.reserve(batch_size_);
- cached_ops_.reserve(batch_size_);
+ cached_ops_.reserve(batch_size_ * kNonDataOpBufferSize);
}
if (batch_size_ > 1) {
@@ -214,15 +214,6 @@
return false;
}
}
-
- // TODO: b/322279333
- // Set compression factor to 4k during estimation.
- // Once COW estimator is ready to support variable
- // block size, this check has to be removed.
- if (IsEstimating()) {
- header_.max_compression_size = header_.block_size;
- }
-
return true;
}
@@ -310,6 +301,14 @@
return true;
}
+size_t CowWriterV3::CachedDataSize() const {
+ size_t size = 0;
+ for (const auto& i : cached_data_) {
+ size += i.size();
+ }
+ return size;
+}
+
bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
if (!CheckOpCount(num_blocks)) {
return false;
@@ -342,7 +341,8 @@
// Allow bigger batch sizes for ops without data. A single CowOperationV3
// struct uses 14 bytes of memory, even if we cache 200 * 16 ops in memory,
// it's only ~44K.
- return cached_data_.size() >= batch_size_ || cached_ops_.size() >= batch_size_ * 16;
+ return CachedDataSize() >= batch_size_ * header_.block_size ||
+ cached_ops_.size() >= batch_size_ * kNonDataOpBufferSize;
}
bool CowWriterV3::ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
@@ -396,13 +396,13 @@
return false;
}
const auto bytes = reinterpret_cast<const uint8_t*>(data);
- const size_t num_blocks = (size / header_.block_size);
- 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);
-
- if (!ConstructCowOpCompressedBuffers(new_block_start + i, bytes + header_.block_size * i,
- old_block + i, offset, type, blocks_to_write)) {
+ size_t num_blocks = (size / header_.block_size);
+ size_t total_written = 0;
+ while (total_written < num_blocks) {
+ size_t chunk = std::min(num_blocks - total_written, batch_size_);
+ if (!ConstructCowOpCompressedBuffers(new_block_start + total_written,
+ bytes + header_.block_size * total_written,
+ old_block + total_written, offset, type, chunk)) {
return false;
}
@@ -412,8 +412,7 @@
<< ", op type: " << type;
return false;
}
-
- i += blocks_to_write;
+ total_written += chunk;
}
return true;
@@ -481,7 +480,8 @@
header_.sequence_data_count = num_ops;
- // Ensure next_data_pos_ is updated as previously initialized + the newly added sequence buffer.
+ // Ensure next_data_pos_ is updated as previously initialized + the newly added sequence
+ // buffer.
CHECK_EQ(next_data_pos_ + header_.sequence_data_count * sizeof(uint32_t),
GetDataOffset(header_));
next_data_pos_ = GetDataOffset(header_);
@@ -639,8 +639,8 @@
// 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
+ // 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]);
}
@@ -716,13 +716,29 @@
return false;
}
if (!data.empty()) {
- const auto ret = pwritev(fd_, data.data(), data.size(), next_data_pos_);
- if (ret != total_data_size) {
- PLOG(ERROR) << "write failed for data of size: " << data.size()
- << " at offset: " << next_data_pos_ << " " << ret;
+ int total_written = 0;
+ int i = 0;
+ while (i < data.size()) {
+ int chunk = std::min(static_cast<int>(data.size() - i), IOV_MAX);
+
+ const auto ret = pwritev(fd_, data.data() + i, chunk, next_data_pos_ + total_written);
+ if (ret < 0) {
+ PLOG(ERROR) << "write failed chunk size of: " << chunk
+ << " at offset: " << next_data_pos_ + total_written << " " << errno;
+ return false;
+ }
+ total_written += ret;
+ i += chunk;
+ }
+ if (total_written != total_data_size) {
+ PLOG(ERROR) << "write failed for data vector of size: " << data.size()
+ << " and total data length: " << total_data_size
+ << " at offset: " << next_data_pos_ << " " << errno
+ << ", only wrote: " << total_written;
return false;
}
}
+
header_.op_count += ops.size();
next_data_pos_ += total_data_size;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 48eb67b..871ed27 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -28,6 +28,9 @@
namespace snapshot {
using namespace android::storage_literals;
+// This is a multiple on top of the number of data ops that can be stored in our cache at once. This
+// is added so that we can cache more non-data ops as it takes up less space.
+static constexpr uint32_t kNonDataOpBufferSize = 16;
class CowWriterV3 : public CowWriterBase {
public:
@@ -91,7 +94,7 @@
}
return false;
}
-
+ size_t CachedDataSize() const;
bool ReadBackVerification();
bool FlushCacheOps();
void InitWorkers();
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e6c4de6..7ca53ad 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -24,7 +24,6 @@
#include <filesystem>
#include <optional>
#include <thread>
-#include <unordered_set>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -46,7 +45,6 @@
#include <android/snapshot/snapshot.pb.h>
#include <libsnapshot/snapshot_stats.h>
#include "device_info.h"
-#include "libsnapshot_cow/parser_v2.h"
#include "partition_cow_creator.h"
#include "snapshot_metadata_updater.h"
#include "utility.h"
@@ -265,7 +263,6 @@
auto boot_file = GetSnapshotBootIndicatorPath();
std::string contents;
if (!android::base::ReadFileToString(boot_file, &contents)) {
- PLOG(WARNING) << "Cannot read " << boot_file;
return {};
}
return contents;
@@ -2118,6 +2115,53 @@
return update_status.io_uring_enabled();
}
+/*
+ * Please see b/304829384 for more details.
+ *
+ * In Android S, we use dm-snapshot for mounting snapshots and snapshot-merge
+ * process. If the vendor partition continues to be on Android S, then
+ * "snapuserd" binary in first stage ramdisk will be from vendor partition.
+ * Thus, we need to maintain backward compatibility.
+ *
+ * Now, We take a two step approach to maintain the backward compatibility:
+ *
+ * 1: During OTA installation, we will continue to use "user-space" snapshots
+ * for OTA installation as both update-engine and snapuserd binary will be from system partition.
+ * However, during installation, we mark "legacy_snapuserd" in
+ * SnapshotUpdateStatus file to mark that this is a path to support backward compatibility.
+ * Thus, this function will return "false" during OTA installation.
+ *
+ * 2: Post OTA reboot, there are two key steps:
+ * a: During first stage init, "init" and "snapuserd" could be from vendor
+ * partition. This could be from Android S. Thus, the snapshot mount path
+ * will be based off dm-snapshot.
+ *
+ * b: Post selinux transition, "init" and "update-engine" will be "system"
+ * partition. Now, since the snapshots are mounted off dm-snapshot,
+ * update-engine interaction with "snapuserd" should work based off
+ * dm-snapshots.
+ *
+ * TL;DR: update-engine will use the "system" snapuserd for installing new
+ * updates (this is safe as there is no "vendor" snapuserd running during
+ * installation). Post reboot, update-engine will use the legacy path when
+ * communicating with "vendor" snapuserd that was started in first-stage
+ * init. Hence, this function checks:
+ * i: Are we in post OTA reboot
+ * ii: Is the Vendor from Android 12
+ * iii: If both (i) and (ii) are true, then use the dm-snapshot based
+ * approach.
+ *
+ */
+bool SnapshotManager::IsLegacySnapuserdPostReboot() {
+ if (is_legacy_snapuserd_.has_value() && is_legacy_snapuserd_.value() == true) {
+ auto slot = GetCurrentSlot();
+ if (slot == Slot::Target) {
+ return true;
+ }
+ }
+ return false;
+}
+
bool SnapshotManager::UpdateUsesUserSnapshots() {
// This and the following function is constantly
// invoked during snapshot merge. We want to avoid
@@ -2129,7 +2173,12 @@
// during merge phase. Hence, once we know that
// the value is read from disk the very first time,
// it is safe to read successive checks from memory.
+
if (is_snapshot_userspace_.has_value()) {
+ // Check if legacy snapuserd is running post OTA reboot
+ if (IsLegacySnapuserdPostReboot()) {
+ return false;
+ }
return is_snapshot_userspace_.value();
}
@@ -2140,13 +2189,16 @@
}
bool SnapshotManager::UpdateUsesUserSnapshots(LockedFile* lock) {
- // See UpdateUsesUserSnapshots()
- if (is_snapshot_userspace_.has_value()) {
- return is_snapshot_userspace_.value();
+ if (!is_snapshot_userspace_.has_value()) {
+ SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
+ is_snapshot_userspace_ = update_status.userspace_snapshots();
+ is_legacy_snapuserd_ = update_status.legacy_snapuserd();
}
- SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
- is_snapshot_userspace_ = update_status.userspace_snapshots();
+ if (IsLegacySnapuserdPostReboot()) {
+ return false;
+ }
+
return is_snapshot_userspace_.value();
}
@@ -2964,6 +3016,7 @@
status.set_merge_phase(old_status.merge_phase());
status.set_userspace_snapshots(old_status.userspace_snapshots());
status.set_io_uring_enabled(old_status.io_uring_enabled());
+ status.set_legacy_snapuserd(old_status.legacy_snapuserd());
}
return WriteSnapshotUpdateStatus(lock, status);
}
@@ -3210,6 +3263,8 @@
// Deduce supported features.
bool userspace_snapshots = CanUseUserspaceSnapshots();
bool legacy_compression = GetLegacyCompressionEnabledProperty();
+ bool is_legacy_snapuserd = IsVendorFromAndroid12();
+
if (!vabc_disable_reason.empty()) {
if (userspace_snapshots) {
LOG(INFO) << "Userspace snapshots disabled: " << vabc_disable_reason;
@@ -3219,6 +3274,7 @@
}
userspace_snapshots = false;
legacy_compression = false;
+ is_legacy_snapuserd = false;
}
if (legacy_compression || userspace_snapshots) {
@@ -3231,6 +3287,11 @@
}
}
+ if (!userspace_snapshots && is_legacy_snapuserd && legacy_compression) {
+ userspace_snapshots = true;
+ LOG(INFO) << "Vendor from Android 12. Enabling userspace snapshot for OTA install";
+ }
+
const bool using_snapuserd = userspace_snapshots || legacy_compression;
if (!using_snapuserd) {
LOG(INFO) << "Using legacy Virtual A/B (dm-snapshot)";
@@ -3246,7 +3307,7 @@
compression_algorithm = "gz";
}
LOG(INFO) << "using compression algorithm: " << compression_algorithm
- << ", max compressible block size: " << compression_factor;
+ << ", max compressible block size: " << compression_factor;
}
PartitionCowCreator cow_creator{
@@ -3328,6 +3389,11 @@
status.set_io_uring_enabled(true);
LOG(INFO) << "io_uring for snapshots enabled";
}
+
+ if (is_legacy_snapuserd) {
+ LOG(INFO) << "Setting legacy_snapuserd to true";
+ status.set_legacy_snapuserd(true);
+ }
} else if (legacy_compression) {
LOG(INFO) << "Virtual A/B using legacy snapuserd";
} else {
@@ -3335,6 +3401,7 @@
}
is_snapshot_userspace_.emplace(userspace_snapshots);
+ is_legacy_snapuserd_.emplace(is_legacy_snapuserd);
if (!device()->IsTestDevice() && using_snapuserd) {
// Terminate stale daemon if any
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 47e6ce9..80dad17 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -56,14 +56,12 @@
#if defined(LIBSNAPSHOT_TEST_VAB_LEGACY)
#define DEFAULT_MODE "vab-legacy"
-#elif defined(LIBSNAPSHOT_TEST_VABC_LEGACY)
-#define DEFAULT_MODE "vabc-legacy"
#else
#define DEFAULT_MODE ""
#endif
DEFINE_string(force_mode, DEFAULT_MODE,
- "Force testing older modes (vab-legacy, vabc-legacy) ignoring device config.");
+ "Force testing older modes (vab-legacy) ignoring device config.");
DEFINE_string(force_iouring_disable, "",
"Force testing mode (iouring_disabled) - disable io_uring");
DEFINE_string(compression_method, "gz", "Default compression algorithm.");
@@ -140,17 +138,10 @@
void SetupProperties() {
std::unordered_map<std::string, std::string> properties;
- ASSERT_TRUE(android::base::SetProperty("snapuserd.test.dm.snapshots", "0"))
- << "Failed to disable property: virtual_ab.userspace.snapshots.enabled";
ASSERT_TRUE(android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0"))
<< "Failed to set property: snapuserd.test.io_uring.disabled";
- if (FLAGS_force_mode == "vabc-legacy") {
- ASSERT_TRUE(android::base::SetProperty("snapuserd.test.dm.snapshots", "1"))
- << "Failed to disable property: virtual_ab.userspace.snapshots.enabled";
- properties["ro.virtual_ab.compression.enabled"] = "true";
- properties["ro.virtual_ab.userspace.snapshots.enabled"] = "false";
- } else if (FLAGS_force_mode == "vab-legacy") {
+ if (FLAGS_force_mode == "vab-legacy") {
properties["ro.virtual_ab.compression.enabled"] = "false";
properties["ro.virtual_ab.userspace.snapshots.enabled"] = "false";
}
@@ -2892,22 +2883,29 @@
::testing::AddGlobalTestEnvironment(new ::android::snapshot::SnapshotTestEnvironment());
gflags::ParseCommandLineFlags(&argc, &argv, false);
- android::base::SetProperty("ctl.stop", "snapuserd");
+ bool vab_legacy = false;
+ if (FLAGS_force_mode == "vab-legacy") {
+ vab_legacy = true;
+ }
- std::unordered_set<std::string> modes = {"", "vab-legacy", "vabc-legacy"};
+ if (!vab_legacy) {
+ // This is necessary if the configuration we're testing doesn't match the device.
+ android::base::SetProperty("ctl.stop", "snapuserd");
+ android::snapshot::KillSnapuserd();
+ }
+
+ std::unordered_set<std::string> modes = {"", "vab-legacy"};
if (modes.count(FLAGS_force_mode) == 0) {
std::cerr << "Unexpected force_config argument\n";
return 1;
}
- // This is necessary if the configuration we're testing doesn't match the device.
- android::snapshot::KillSnapuserd();
-
int ret = RUN_ALL_TESTS();
- android::base::SetProperty("snapuserd.test.dm.snapshots", "0");
android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
- android::snapshot::KillSnapuserd();
+ if (!vab_legacy) {
+ android::snapshot::KillSnapuserd();
+ }
return ret;
}
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 50e9f48..0158d4d 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -47,11 +47,16 @@
#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;
@@ -89,6 +94,7 @@
namespace android {
namespace snapshot {
+#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
class MapSnapshots {
public:
MapSnapshots(std::string path = "");
@@ -104,6 +110,7 @@
private:
std::optional<std::string> GetCowImagePath(std::string& name);
bool PrepareUpdate();
+ bool GetCowDevicePath(std::string partition_name, std::string* cow_path);
bool WriteSnapshotPatch(std::string cow_device, std::string patch);
std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
const std::string& partiton_name);
@@ -225,6 +232,23 @@
return true;
}
+bool MapSnapshots::GetCowDevicePath(std::string partition_name, std::string* cow_path) {
+ auto& dm = android::dm::DeviceMapper::Instance();
+ std::string cow_device = partition_name + "-cow";
+ if (dm.GetDmDevicePathByName(cow_device, cow_path)) {
+ return true;
+ }
+
+ LOG(INFO) << "Failed to find cow path: " << cow_device << " Checking the device for -img path";
+ // If the COW device exists only on /data
+ cow_device = partition_name + "-cow-img";
+ if (!dm.GetDmDevicePathByName(cow_device, cow_path)) {
+ LOG(ERROR) << "Failed to cow path: " << cow_device;
+ return false;
+ }
+ return true;
+}
+
bool MapSnapshots::ApplyUpdate() {
if (!PrepareUpdate()) {
LOG(ERROR) << "PrepareUpdate failed";
@@ -247,15 +271,13 @@
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";
+ if (!GetCowDevicePath(partition_name, &cow_path)) {
+ LOG(ERROR) << "Failed to find cow path";
return false;
}
threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,
@@ -459,29 +481,31 @@
}
return true;
}
+#endif
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;
}
+#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
bool GetVerityPartitions(std::vector<std::string>& partitions) {
auto& dm = android::dm::DeviceMapper::Instance();
auto dm_block_devices = dm.FindDmPartitions();
@@ -634,7 +658,6 @@
return cow.FinishSnapshotWrites();
}
-#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
bool CreateTestUpdate(SnapshotManager* sm) {
chromeos_update_engine::DeltaArchiveManifest manifest;
@@ -758,13 +781,13 @@
{"map", MapCmdHandler},
#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
{"test-blank-ota", TestOtaHandler},
-#endif
- {"unmap", UnmapCmdHandler},
{"apply-update", ApplyUpdate},
{"map-snapshots", MapPrecreatedSnapshots},
{"unmap-snapshots", UnMapPrecreatedSnapshots},
{"delete-snapshots", DeletePrecreatedSnapshots},
{"revert-snapshots", RemovePrecreatedSnapshots},
+#endif
+ {"unmap", UnmapCmdHandler},
// clang-format on
};
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index bd296a3..649309d 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -59,9 +59,6 @@
],
local_include_dirs: ["include/"],
srcs: [
- "dm-snapshot-merge/snapuserd.cpp",
- "dm-snapshot-merge/snapuserd_readahead.cpp",
- "dm-snapshot-merge/snapuserd_worker.cpp",
"dm_user_block_server.cpp",
"snapuserd_buffer.cpp",
"user-space-merge/handler_manager.cpp",
@@ -109,7 +106,6 @@
"fs_mgr_defaults",
],
srcs: [
- "dm-snapshot-merge/snapuserd_server.cpp",
"snapuserd_daemon.cpp",
"user-space-merge/snapuserd_server.cpp",
],
@@ -190,45 +186,6 @@
symlinks: ["snapuserd"],
}
-cc_test {
- name: "snapuserd_test_legacy",
- defaults: [
- "fs_mgr_defaults",
- "libsnapshot_cow_defaults",
- ],
- srcs: [
- "dm-snapshot-merge/cow_snapuserd_test.cpp",
- "dm-snapshot-merge/snapuserd.cpp",
- "dm-snapshot-merge/snapuserd_worker.cpp",
- "snapuserd_buffer.cpp",
- ],
- shared_libs: [
- "libbase",
- "liblog",
- ],
- static_libs: [
- "libbrotli",
- "libgtest",
- "libsnapshot_cow",
- "libsnapuserd_client",
- "libcutils_sockets",
- "libz",
- "libdm",
- "libext2_uuid",
- "libext4_utils",
- "libfs_mgr_file_wait",
- ],
- header_libs: [
- "libstorage_literals_headers",
- "libfiemap_headers",
- ],
- test_options: {
- min_shipping_api_level: 30,
- },
- auto_gen_config: true,
- require_root: false,
-}
-
cc_defaults {
name: "snapuserd_test_defaults",
defaults: [
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
deleted file mode 100644
index 737c480..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
+++ /dev/null
@@ -1,1238 +0,0 @@
-// Copyright (C) 2018 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <fcntl.h>
-#include <linux/fs.h>
-#include <linux/memfd.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <chrono>
-#include <iostream>
-#include <memory>
-#include <string_view>
-
-#include <android-base/file.h>
-#include <android-base/unique_fd.h>
-#include <fs_mgr/file_wait.h>
-#include <gtest/gtest.h>
-#include <libdm/dm.h>
-#include <libdm/loop_control.h>
-#include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_buffer.h>
-#include <snapuserd/snapuserd_client.h>
-#include <storage_literals/storage_literals.h>
-
-#include "snapuserd.h"
-
-namespace android {
-namespace snapshot {
-
-using namespace android::storage_literals;
-using android::base::unique_fd;
-using LoopDevice = android::dm::LoopDevice;
-using namespace std::chrono_literals;
-using namespace android::dm;
-using namespace std;
-
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
-class TempDevice {
- public:
- TempDevice(const std::string& name, const DmTable& table)
- : dm_(DeviceMapper::Instance()), name_(name), valid_(false) {
- valid_ = dm_.CreateDevice(name, table, &path_, std::chrono::seconds(5));
- }
- TempDevice(TempDevice&& other) noexcept
- : dm_(other.dm_), name_(other.name_), path_(other.path_), valid_(other.valid_) {
- other.valid_ = false;
- }
- ~TempDevice() {
- if (valid_) {
- dm_.DeleteDevice(name_);
- }
- }
- bool Destroy() {
- if (!valid_) {
- return false;
- }
- valid_ = false;
- return dm_.DeleteDevice(name_);
- }
- const std::string& path() const { return path_; }
- const std::string& name() const { return name_; }
- bool valid() const { return valid_; }
-
- TempDevice(const TempDevice&) = delete;
- TempDevice& operator=(const TempDevice&) = delete;
-
- TempDevice& operator=(TempDevice&& other) noexcept {
- name_ = other.name_;
- valid_ = other.valid_;
- other.valid_ = false;
- return *this;
- }
-
- private:
- DeviceMapper& dm_;
- std::string name_;
- std::string path_;
- bool valid_;
-};
-
-class CowSnapuserdTest final {
- public:
- bool Setup();
- bool SetupOrderedOps();
- bool SetupOrderedOpsInverted();
- bool SetupCopyOverlap_1();
- bool SetupCopyOverlap_2();
- bool Merge();
- void ValidateMerge();
- void ReadSnapshotDeviceAndValidate();
- void Shutdown();
- void MergeInterrupt();
- void MergeInterruptFixed(int duration);
- void MergeInterruptRandomly(int max_duration);
- void ReadDmUserBlockWithoutDaemon();
- void ReadLastBlock();
-
- std::string snapshot_dev() const { return snapshot_dev_->path(); }
-
- static const uint64_t kSectorSize = 512;
-
- private:
- void SetupImpl();
-
- void MergeImpl();
- void SimulateDaemonRestart();
- void StartMerge();
-
- std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
- void CreateCowDevice();
- void CreateCowDeviceOrderedOps();
- void CreateCowDeviceOrderedOpsInverted();
- void CreateCowDeviceWithCopyOverlap_1();
- void CreateCowDeviceWithCopyOverlap_2();
- bool SetupDaemon();
- void CreateBaseDevice();
- void InitCowDevice();
- void SetDeviceControlName();
- void InitDaemon();
- void CreateDmUserDevice();
- void StartSnapuserdDaemon();
- void CreateSnapshotDevice();
-
- unique_ptr<LoopDevice> base_loop_;
- unique_ptr<TempDevice> dmuser_dev_;
- unique_ptr<TempDevice> snapshot_dev_;
-
- std::string system_device_ctrl_name_;
- std::string system_device_name_;
-
- unique_fd base_fd_;
- std::unique_ptr<TemporaryFile> cow_system_;
- std::unique_ptr<SnapuserdClient> client_;
- std::unique_ptr<uint8_t[]> orig_buffer_;
- std::unique_ptr<uint8_t[]> merged_buffer_;
- bool setup_ok_ = false;
- bool merge_ok_ = false;
- size_t size_ = 50_MiB;
- int cow_num_sectors_;
- int total_base_size_;
-};
-
-class CowSnapuserdMetadataTest final {
- public:
- void Setup();
- void SetupPartialArea();
- void ValidateMetadata();
- void ValidatePartialFilledArea();
-
- private:
- void InitMetadata();
- std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
- void CreateCowDevice();
- void CreateCowPartialFilledArea();
-
- std::unique_ptr<Snapuserd> snapuserd_;
- std::unique_ptr<TemporaryFile> cow_system_;
- size_t size_ = 1_MiB;
-};
-
-static unique_fd CreateTempFile(const std::string& name, size_t size) {
- unique_fd fd(syscall(__NR_memfd_create, name.c_str(), MFD_ALLOW_SEALING));
- if (fd < 0) {
- return {};
- }
- if (size) {
- if (ftruncate(fd, size) < 0) {
- perror("ftruncate");
- return {};
- }
- if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) < 0) {
- perror("fcntl");
- return {};
- }
- }
- return fd;
-}
-
-void CowSnapuserdTest::Shutdown() {
- ASSERT_TRUE(snapshot_dev_->Destroy());
- ASSERT_TRUE(dmuser_dev_->Destroy());
-
- auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
- ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
- ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
- ASSERT_TRUE(client_->DetachSnapuserd());
-}
-
-bool CowSnapuserdTest::Setup() {
- SetupImpl();
- return setup_ok_;
-}
-
-bool CowSnapuserdTest::SetupOrderedOps() {
- CreateBaseDevice();
- CreateCowDeviceOrderedOps();
- return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupOrderedOpsInverted() {
- CreateBaseDevice();
- CreateCowDeviceOrderedOpsInverted();
- return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupCopyOverlap_1() {
- CreateBaseDevice();
- CreateCowDeviceWithCopyOverlap_1();
- return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupCopyOverlap_2() {
- CreateBaseDevice();
- CreateCowDeviceWithCopyOverlap_2();
- return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupDaemon() {
- SetDeviceControlName();
-
- StartSnapuserdDaemon();
- InitCowDevice();
-
- CreateDmUserDevice();
- InitDaemon();
-
- CreateSnapshotDevice();
- setup_ok_ = true;
-
- return setup_ok_;
-}
-
-void CowSnapuserdTest::StartSnapuserdDaemon() {
- pid_t pid = fork();
- ASSERT_GE(pid, 0);
- if (pid == 0) {
- std::string arg0 = "/system/bin/snapuserd";
- std::string arg1 = "-socket="s + kSnapuserdSocketTest;
- char* const argv[] = {arg0.data(), arg1.data(), nullptr};
- ASSERT_GE(execv(arg0.c_str(), argv), 0);
- } else {
- client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
- ASSERT_NE(client_, nullptr);
- }
-}
-
-std::unique_ptr<ICowWriter> CowSnapuserdTest::CreateCowDeviceInternal() {
- std::string path = android::base::GetExecutableDirectory();
- cow_system_ = std::make_unique<TemporaryFile>(path);
-
- CowOptions options;
- options.compression = "gz";
-
- unique_fd fd(cow_system_->fd);
- cow_system_->fd = -1;
-
- return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
-}
-
-void CowSnapuserdTest::ReadLastBlock() {
- unique_fd rnd_fd;
- total_base_size_ = BLOCK_SZ * 2;
-
- base_fd_ = CreateTempFile("base_device", total_base_size_);
- ASSERT_GE(base_fd_, 0);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
-
- for (size_t j = 0; j < ((total_base_size_) / BLOCK_SZ); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), BLOCK_SZ, 0), true);
- ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), BLOCK_SZ), true);
- }
-
- ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-
- base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
- ASSERT_TRUE(base_loop_->valid());
-
- std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(total_base_size_);
- loff_t offset = 0;
-
- // Fill random data
- for (size_t j = 0; j < (total_base_size_ / BLOCK_SZ); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, BLOCK_SZ, 0),
- true);
-
- offset += BLOCK_SZ;
- }
-
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- ASSERT_TRUE(writer->AddRawBlocks(0, random_buffer_1_.get(), BLOCK_SZ));
- ASSERT_TRUE(writer->AddRawBlocks(1, (char*)random_buffer_1_.get() + BLOCK_SZ, BLOCK_SZ));
-
- ASSERT_TRUE(writer->Finalize());
-
- SetDeviceControlName();
-
- StartSnapuserdDaemon();
- InitCowDevice();
-
- CreateDmUserDevice();
- InitDaemon();
-
- CreateSnapshotDevice();
-
- unique_fd snapshot_fd(open(snapshot_dev_->path().c_str(), O_RDONLY));
- ASSERT_TRUE(snapshot_fd > 0);
-
- std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
-
- offset = 7680;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), 512, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)random_buffer_1_.get() + offset, 512), 0);
-}
-
-void CowSnapuserdTest::CreateBaseDevice() {
- unique_fd rnd_fd;
-
- total_base_size_ = (size_ * 5);
- base_fd_ = CreateTempFile("base_device", total_base_size_);
- ASSERT_GE(base_fd_, 0);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(1_MiB);
-
- for (size_t j = 0; j < ((total_base_size_) / 1_MiB); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), 1_MiB, 0), true);
- ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), 1_MiB), true);
- }
-
- ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-
- base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
- ASSERT_TRUE(base_loop_->valid());
-}
-
-void CowSnapuserdTest::ReadSnapshotDeviceAndValidate() {
- unique_fd snapshot_fd(open(snapshot_dev_->path().c_str(), O_RDONLY));
- ASSERT_TRUE(snapshot_fd > 0);
-
- std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
-
- // COPY
- loff_t offset = 0;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), size_), 0);
-
- // REPLACE
- offset += size_;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + size_, size_), 0);
-
- // ZERO
- offset += size_;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 2), size_), 0);
-
- // REPLACE
- offset += size_;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 3), size_), 0);
-
- // XOR
- offset += size_;
- ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
- ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
-}
-
-void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- size_t num_blocks = size_ / writer->GetBlockSize();
- size_t x = num_blocks;
- size_t blk_src_copy = 0;
-
- // Create overlapping copy operations
- while (1) {
- ASSERT_TRUE(writer->AddCopy(blk_src_copy, blk_src_copy + 1));
- x -= 1;
- if (x == 1) {
- break;
- }
- blk_src_copy += 1;
- }
-
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
-
- // Construct the buffer required for validation
- orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-
- // Read the entire base device
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
- true);
-
- // Merged operations required for validation
- int block_size = 4096;
- x = num_blocks;
- loff_t src_offset = block_size;
- loff_t dest_offset = 0;
-
- while (1) {
- memmove((char*)orig_buffer_.get() + dest_offset, (char*)orig_buffer_.get() + src_offset,
- block_size);
- x -= 1;
- if (x == 1) {
- break;
- }
- src_offset += block_size;
- dest_offset += block_size;
- }
-}
-
-void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- size_t num_blocks = size_ / writer->GetBlockSize();
- size_t x = num_blocks;
- size_t blk_src_copy = num_blocks - 1;
-
- // Create overlapping copy operations
- while (1) {
- ASSERT_TRUE(writer->AddCopy(blk_src_copy + 1, blk_src_copy));
- x -= 1;
- if (x == 0) {
- ASSERT_EQ(blk_src_copy, 0);
- break;
- }
- blk_src_copy -= 1;
- }
-
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
-
- // Construct the buffer required for validation
- orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-
- // Read the entire base device
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
- true);
-
- // Merged operations
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), writer->GetBlockSize(),
- 0),
- true);
- ASSERT_EQ(android::base::ReadFullyAtOffset(
- base_fd_, (char*)orig_buffer_.get() + writer->GetBlockSize(), size_, 0),
- true);
-}
-
-void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
- unique_fd rnd_fd;
- loff_t offset = 0;
-
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
- // Fill random data
- for (size_t j = 0; j < (size_ / 1_MiB); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
- true);
-
- offset += 1_MiB;
- }
-
- size_t num_blocks = size_ / writer->GetBlockSize();
- size_t blk_end_copy = num_blocks * 3;
- size_t source_blk = num_blocks - 1;
- size_t blk_src_copy = blk_end_copy - 1;
- uint16_t xor_offset = 5;
-
- size_t x = num_blocks;
- while (1) {
- ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
- x -= 1;
- if (x == 0) {
- break;
- }
- source_blk -= 1;
- blk_src_copy -= 1;
- }
-
- for (size_t i = num_blocks; i > 0; i--) {
- ASSERT_TRUE(writer->AddXorBlocks(
- num_blocks + i - 1, &random_buffer_1_.get()[writer->GetBlockSize() * (i - 1)],
- writer->GetBlockSize(), 2 * num_blocks + i - 1, xor_offset));
- }
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
- // Construct the buffer required for validation
- orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
- // Read the entire base device
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
- true);
- // Merged Buffer
- memmove(orig_buffer_.get(), (char*)orig_buffer_.get() + 2 * size_, size_);
- memmove(orig_buffer_.get() + size_, (char*)orig_buffer_.get() + 2 * size_ + xor_offset, size_);
- for (int i = 0; i < size_; i++) {
- orig_buffer_.get()[size_ + i] ^= random_buffer_1_.get()[i];
- }
-}
-
-void CowSnapuserdTest::CreateCowDeviceOrderedOps() {
- unique_fd rnd_fd;
- loff_t offset = 0;
-
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
- // Fill random data
- for (size_t j = 0; j < (size_ / 1_MiB); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
- true);
-
- offset += 1_MiB;
- }
- memset(random_buffer_1_.get(), 0, size_);
-
- size_t num_blocks = size_ / writer->GetBlockSize();
- size_t x = num_blocks;
- size_t source_blk = 0;
- size_t blk_src_copy = 2 * num_blocks;
- uint16_t xor_offset = 5;
-
- while (1) {
- ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
-
- x -= 1;
- if (x == 0) {
- break;
- }
- source_blk += 1;
- blk_src_copy += 1;
- }
-
- ASSERT_TRUE(writer->AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
- xor_offset));
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
- // Construct the buffer required for validation
- orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
- // Read the entire base device
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
- true);
- // Merged Buffer
- memmove(orig_buffer_.get(), (char*)orig_buffer_.get() + 2 * size_, size_);
- memmove(orig_buffer_.get() + size_, (char*)orig_buffer_.get() + 2 * size_ + xor_offset, size_);
- for (int i = 0; i < size_; i++) {
- orig_buffer_.get()[size_ + i] ^= random_buffer_1_.get()[i];
- }
-}
-
-void CowSnapuserdTest::CreateCowDevice() {
- unique_fd rnd_fd;
- loff_t offset = 0;
-
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
- // Fill random data
- for (size_t j = 0; j < (size_ / 1_MiB); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
- true);
-
- offset += 1_MiB;
- }
-
- size_t num_blocks = size_ / writer->GetBlockSize();
- size_t blk_end_copy = num_blocks * 2;
- size_t source_blk = num_blocks - 1;
- size_t blk_src_copy = blk_end_copy - 1;
-
- uint32_t sequence[num_blocks * 2];
- // Sequence for Copy ops
- for (int i = 0; i < num_blocks; i++) {
- sequence[i] = num_blocks - 1 - i;
- }
- // Sequence for Xor ops
- for (int i = 0; i < num_blocks; i++) {
- sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
- }
- ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
-
- size_t x = num_blocks;
- while (1) {
- ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
- x -= 1;
- if (x == 0) {
- break;
- }
- source_blk -= 1;
- blk_src_copy -= 1;
- }
-
- source_blk = num_blocks;
- blk_src_copy = blk_end_copy;
-
- ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
-
- size_t blk_zero_copy_start = source_blk + num_blocks;
- size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
-
- ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
-
- size_t blk_random2_replace_start = blk_zero_copy_end;
-
- ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
-
- size_t blk_xor_start = blk_random2_replace_start + num_blocks;
- size_t xor_offset = BLOCK_SZ / 2;
- ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
- xor_offset));
-
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
- // Construct the buffer required for validation
- orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
- std::string zero_buffer(size_, 0);
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), size_, size_), true);
- memcpy((char*)orig_buffer_.get() + size_, random_buffer_1_.get(), size_);
- memcpy((char*)orig_buffer_.get() + (size_ * 2), (void*)zero_buffer.c_str(), size_);
- memcpy((char*)orig_buffer_.get() + (size_ * 3), random_buffer_1_.get(), size_);
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, &orig_buffer_.get()[size_ * 4], size_,
- size_ + xor_offset),
- true);
- for (int i = 0; i < size_; i++) {
- orig_buffer_.get()[(size_ * 4) + i] =
- (uint8_t)(orig_buffer_.get()[(size_ * 4) + i] ^ random_buffer_1_.get()[i]);
- }
-}
-
-void CowSnapuserdTest::InitCowDevice() {
- cow_num_sectors_ = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
- base_loop_->device());
- ASSERT_NE(cow_num_sectors_, 0);
-}
-
-void CowSnapuserdTest::SetDeviceControlName() {
- system_device_name_.clear();
- system_device_ctrl_name_.clear();
-
- std::string str(cow_system_->path);
- std::size_t found = str.find_last_of("/\\");
- ASSERT_NE(found, std::string::npos);
- system_device_name_ = str.substr(found + 1);
-
- system_device_ctrl_name_ = system_device_name_ + "-ctrl";
-}
-
-void CowSnapuserdTest::CreateDmUserDevice() {
- DmTable dmuser_table;
- ASSERT_TRUE(dmuser_table.AddTarget(
- std::make_unique<DmTargetUser>(0, cow_num_sectors_, system_device_ctrl_name_)));
- ASSERT_TRUE(dmuser_table.valid());
-
- dmuser_dev_ = std::make_unique<TempDevice>(system_device_name_, dmuser_table);
- ASSERT_TRUE(dmuser_dev_->valid());
- ASSERT_FALSE(dmuser_dev_->path().empty());
-
- auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
- ASSERT_TRUE(android::fs_mgr::WaitForFile(misc_device, 10s));
-}
-
-void CowSnapuserdTest::ReadDmUserBlockWithoutDaemon() {
- DmTable dmuser_table;
- std::string dm_user_name = "dm-test-device";
- unique_fd fd;
-
- // Create a dm-user block device
- ASSERT_TRUE(dmuser_table.AddTarget(std::make_unique<DmTargetUser>(0, 123456, dm_user_name)));
- ASSERT_TRUE(dmuser_table.valid());
-
- dmuser_dev_ = std::make_unique<TempDevice>(dm_user_name, dmuser_table);
- ASSERT_TRUE(dmuser_dev_->valid());
- ASSERT_FALSE(dmuser_dev_->path().empty());
-
- fd.reset(open(dmuser_dev_->path().c_str(), O_RDONLY));
- ASSERT_GE(fd, 0);
-
- std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(1_MiB);
-
- loff_t offset = 0;
- // Every IO should fail as there is no daemon to process the IO
- for (size_t j = 0; j < 10; j++) {
- ASSERT_EQ(ReadFullyAtOffset(fd, (char*)buffer.get() + offset, BLOCK_SZ, offset), false);
-
- offset += BLOCK_SZ;
- }
-
- fd = {};
- ASSERT_TRUE(dmuser_dev_->Destroy());
-}
-
-void CowSnapuserdTest::InitDaemon() {
- bool ok = client_->AttachDmUser(system_device_ctrl_name_);
- ASSERT_TRUE(ok);
-}
-
-void CowSnapuserdTest::CreateSnapshotDevice() {
- DmTable snap_table;
- ASSERT_TRUE(snap_table.AddTarget(std::make_unique<DmTargetSnapshot>(
- 0, total_base_size_ / kSectorSize, base_loop_->device(), dmuser_dev_->path(),
- SnapshotStorageMode::Persistent, 8)));
- ASSERT_TRUE(snap_table.valid());
-
- snap_table.set_readonly(true);
-
- snapshot_dev_ = std::make_unique<TempDevice>("cowsnapuserd-test-dm-snapshot", snap_table);
- ASSERT_TRUE(snapshot_dev_->valid());
- ASSERT_FALSE(snapshot_dev_->path().empty());
-}
-
-void CowSnapuserdTest::SetupImpl() {
- CreateBaseDevice();
- CreateCowDevice();
-
- SetDeviceControlName();
-
- StartSnapuserdDaemon();
- InitCowDevice();
-
- CreateDmUserDevice();
- InitDaemon();
-
- CreateSnapshotDevice();
- setup_ok_ = true;
-}
-
-bool CowSnapuserdTest::Merge() {
- MergeImpl();
- return merge_ok_;
-}
-
-void CowSnapuserdTest::StartMerge() {
- DmTable merge_table;
- ASSERT_TRUE(merge_table.AddTarget(std::make_unique<DmTargetSnapshot>(
- 0, total_base_size_ / kSectorSize, base_loop_->device(), dmuser_dev_->path(),
- SnapshotStorageMode::Merge, 8)));
- ASSERT_TRUE(merge_table.valid());
- ASSERT_EQ(total_base_size_ / kSectorSize, merge_table.num_sectors());
-
- DeviceMapper& dm = DeviceMapper::Instance();
- ASSERT_TRUE(dm.LoadTableAndActivate("cowsnapuserd-test-dm-snapshot", merge_table));
-}
-
-void CowSnapuserdTest::MergeImpl() {
- StartMerge();
- DeviceMapper& dm = DeviceMapper::Instance();
-
- while (true) {
- vector<DeviceMapper::TargetInfo> status;
- ASSERT_TRUE(dm.GetTableStatus("cowsnapuserd-test-dm-snapshot", &status));
- ASSERT_EQ(status.size(), 1);
- ASSERT_EQ(strncmp(status[0].spec.target_type, "snapshot-merge", strlen("snapshot-merge")),
- 0);
-
- DmTargetSnapshot::Status merge_status;
- ASSERT_TRUE(DmTargetSnapshot::ParseStatusText(status[0].data, &merge_status));
- ASSERT_TRUE(merge_status.error.empty());
- if (merge_status.sectors_allocated == merge_status.metadata_sectors) {
- break;
- }
-
- std::this_thread::sleep_for(250ms);
- }
-
- merge_ok_ = true;
-}
-
-void CowSnapuserdTest::ValidateMerge() {
- merged_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
- ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, merged_buffer_.get(), total_base_size_, 0),
- true);
- ASSERT_EQ(memcmp(merged_buffer_.get(), orig_buffer_.get(), total_base_size_), 0);
-}
-
-void CowSnapuserdTest::SimulateDaemonRestart() {
- Shutdown();
- std::this_thread::sleep_for(500ms);
- SetDeviceControlName();
- StartSnapuserdDaemon();
- InitCowDevice();
- CreateDmUserDevice();
- InitDaemon();
- CreateSnapshotDevice();
-}
-
-void CowSnapuserdTest::MergeInterruptRandomly(int max_duration) {
- std::srand(std::time(nullptr));
- StartMerge();
-
- for (int i = 0; i < 20; i++) {
- int duration = std::rand() % max_duration;
- std::this_thread::sleep_for(std::chrono::milliseconds(duration));
- SimulateDaemonRestart();
- StartMerge();
- }
-
- SimulateDaemonRestart();
- ASSERT_TRUE(Merge());
-}
-
-void CowSnapuserdTest::MergeInterruptFixed(int duration) {
- StartMerge();
-
- for (int i = 0; i < 25; i++) {
- std::this_thread::sleep_for(std::chrono::milliseconds(duration));
- SimulateDaemonRestart();
- StartMerge();
- }
-
- SimulateDaemonRestart();
- ASSERT_TRUE(Merge());
-}
-
-void CowSnapuserdTest::MergeInterrupt() {
- // Interrupt merge at various intervals
- StartMerge();
- std::this_thread::sleep_for(250ms);
- SimulateDaemonRestart();
-
- StartMerge();
- std::this_thread::sleep_for(250ms);
- SimulateDaemonRestart();
-
- StartMerge();
- std::this_thread::sleep_for(150ms);
- SimulateDaemonRestart();
-
- StartMerge();
- std::this_thread::sleep_for(100ms);
- SimulateDaemonRestart();
-
- StartMerge();
- std::this_thread::sleep_for(800ms);
- SimulateDaemonRestart();
-
- StartMerge();
- std::this_thread::sleep_for(600ms);
- SimulateDaemonRestart();
-
- ASSERT_TRUE(Merge());
-}
-
-std::unique_ptr<ICowWriter> CowSnapuserdMetadataTest::CreateCowDeviceInternal() {
- std::string path = android::base::GetExecutableDirectory();
- cow_system_ = std::make_unique<TemporaryFile>(path);
-
- CowOptions options;
- options.compression = "gz";
-
- unique_fd fd(cow_system_->fd);
- cow_system_->fd = -1;
-
- return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
-}
-
-void CowSnapuserdMetadataTest::CreateCowPartialFilledArea() {
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- // Area 0 is completely filled with 256 exceptions
- for (int i = 0; i < 256; i++) {
- ASSERT_TRUE(writer->AddCopy(i, 256 + i));
- }
-
- // Area 1 is partially filled with 2 copy ops and 10 zero ops
- ASSERT_TRUE(writer->AddCopy(500, 1000));
- ASSERT_TRUE(writer->AddCopy(501, 1001));
-
- ASSERT_TRUE(writer->AddZeroBlocks(300, 10));
-
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
-}
-
-void CowSnapuserdMetadataTest::ValidatePartialFilledArea() {
- int area_sz = snapuserd_->GetMetadataAreaSize();
-
- ASSERT_EQ(area_sz, 2);
-
- // Verify the partially filled area
- void* buffer = snapuserd_->GetExceptionBuffer(1);
- loff_t offset = 0;
- struct disk_exception* de;
- for (int i = 11; i >= 0; i--) {
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, i);
- offset += sizeof(struct disk_exception);
- }
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 0);
- ASSERT_EQ(de->new_chunk, 0);
-}
-
-void CowSnapuserdMetadataTest::SetupPartialArea() {
- CreateCowPartialFilledArea();
- InitMetadata();
-}
-
-void CowSnapuserdMetadataTest::CreateCowDevice() {
- unique_fd rnd_fd;
- loff_t offset = 0;
-
- auto writer = CreateCowDeviceInternal();
- ASSERT_NE(writer, nullptr);
-
- rnd_fd.reset(open("/dev/random", O_RDONLY));
- ASSERT_TRUE(rnd_fd > 0);
-
- std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
- // Fill random data
- for (size_t j = 0; j < (size_ / 1_MiB); j++) {
- ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
- true);
-
- offset += 1_MiB;
- }
-
- size_t num_blocks = size_ / writer->GetBlockSize();
-
- // Overlapping region. This has to be split
- // into two batch operations
- ASSERT_TRUE(writer->AddCopy(23, 20));
- ASSERT_TRUE(writer->AddCopy(22, 19));
- ASSERT_TRUE(writer->AddCopy(21, 18));
- ASSERT_TRUE(writer->AddCopy(20, 17));
- ASSERT_TRUE(writer->AddCopy(19, 16));
- ASSERT_TRUE(writer->AddCopy(18, 15));
-
- // Contiguous region but blocks in ascending order
- // Daemon has to ensure that these blocks are merged
- // in a batch
- ASSERT_TRUE(writer->AddCopy(50, 75));
- ASSERT_TRUE(writer->AddCopy(51, 76));
- ASSERT_TRUE(writer->AddCopy(52, 77));
- ASSERT_TRUE(writer->AddCopy(53, 78));
-
- // Dis-contiguous region
- ASSERT_TRUE(writer->AddCopy(110, 130));
- ASSERT_TRUE(writer->AddCopy(105, 125));
- ASSERT_TRUE(writer->AddCopy(100, 120));
-
- // Overlap
- ASSERT_TRUE(writer->AddCopy(25, 30));
- ASSERT_TRUE(writer->AddCopy(30, 31));
-
- size_t source_blk = num_blocks;
-
- ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
-
- size_t blk_zero_copy_start = source_blk + num_blocks;
-
- ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
-
- // Flush operations
- ASSERT_TRUE(writer->Finalize());
-}
-
-void CowSnapuserdMetadataTest::InitMetadata() {
- snapuserd_ = std::make_unique<Snapuserd>("", cow_system_->path, "");
- ASSERT_TRUE(snapuserd_->InitCowDevice());
-}
-
-void CowSnapuserdMetadataTest::Setup() {
- CreateCowDevice();
- InitMetadata();
-}
-
-void CowSnapuserdMetadataTest::ValidateMetadata() {
- int area_sz = snapuserd_->GetMetadataAreaSize();
- ASSERT_EQ(area_sz, 3);
-
- size_t old_chunk;
- size_t new_chunk;
-
- for (int i = 0; i < area_sz; i++) {
- void* buffer = snapuserd_->GetExceptionBuffer(i);
- loff_t offset = 0;
- if (i == 0) {
- old_chunk = 256;
- new_chunk = 2;
- } else if (i == 1) {
- old_chunk = 512;
- new_chunk = 259;
- }
- for (int j = 0; j < 256; j++) {
- struct disk_exception* de =
- reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-
- if (i != 2) {
- ASSERT_EQ(de->old_chunk, old_chunk);
- ASSERT_EQ(de->new_chunk, new_chunk);
- old_chunk += 1;
- new_chunk += 1;
- } else {
- break;
- }
- offset += sizeof(struct disk_exception);
- }
-
- if (i == 2) {
- // The first 5 copy operation is not batch merged
- // as the sequence is discontiguous
- struct disk_exception* de =
- reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 30);
- ASSERT_EQ(de->new_chunk, 518);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 25);
- ASSERT_EQ(de->new_chunk, 520);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 100);
- ASSERT_EQ(de->new_chunk, 521);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 105);
- ASSERT_EQ(de->new_chunk, 522);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 110);
- ASSERT_EQ(de->new_chunk, 523);
- offset += sizeof(struct disk_exception);
-
- // The next 4 operations are batch merged as
- // both old and new chunk are contiguous
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 53);
- ASSERT_EQ(de->new_chunk, 524);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 52);
- ASSERT_EQ(de->new_chunk, 525);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 51);
- ASSERT_EQ(de->new_chunk, 526);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 50);
- ASSERT_EQ(de->new_chunk, 527);
- offset += sizeof(struct disk_exception);
-
- // This is handling overlap operation with
- // two batch merge operations.
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 18);
- ASSERT_EQ(de->new_chunk, 528);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 19);
- ASSERT_EQ(de->new_chunk, 529);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 20);
- ASSERT_EQ(de->new_chunk, 530);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 21);
- ASSERT_EQ(de->new_chunk, 532);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 22);
- ASSERT_EQ(de->new_chunk, 533);
- offset += sizeof(struct disk_exception);
-
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 23);
- ASSERT_EQ(de->new_chunk, 534);
- offset += sizeof(struct disk_exception);
-
- // End of metadata
- de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
- ASSERT_EQ(de->old_chunk, 0);
- ASSERT_EQ(de->new_chunk, 0);
- offset += sizeof(struct disk_exception);
- }
- }
-}
-
-TEST(Snapuserd_Test, Snapshot_Metadata) {
- CowSnapuserdMetadataTest harness;
- harness.Setup();
- harness.ValidateMetadata();
-}
-
-TEST(Snapuserd_Test, Snapshot_Metadata_Overlap) {
- CowSnapuserdMetadataTest harness;
- harness.SetupPartialArea();
- harness.ValidatePartialFilledArea();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Resume) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.Setup());
- harness.MergeInterrupt();
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_IO_TEST) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.Setup());
- harness.ReadSnapshotDeviceAndValidate();
- ASSERT_TRUE(harness.Merge());
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_END_IO_TEST) {
- CowSnapuserdTest harness;
- harness.ReadLastBlock();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_TEST_1) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupCopyOverlap_1());
- ASSERT_TRUE(harness.Merge());
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_TEST_2) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupCopyOverlap_2());
- ASSERT_TRUE(harness.Merge());
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupCopyOverlap_1());
- harness.MergeInterrupt();
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, ReadDmUserBlockWithoutDaemon) {
- CowSnapuserdTest harness;
- harness.ReadDmUserBlockWithoutDaemon();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Fixed_Ordered) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupOrderedOps());
- harness.MergeInterruptFixed(300);
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Random_Ordered) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupOrderedOps());
- harness.MergeInterruptRandomly(500);
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Fixed_Inverted) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupOrderedOpsInverted());
- harness.MergeInterruptFixed(50);
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Random_Inverted) {
- CowSnapuserdTest harness;
- ASSERT_TRUE(harness.SetupOrderedOpsInverted());
- harness.MergeInterruptRandomly(50);
- harness.ValidateMerge();
- harness.Shutdown();
-}
-
-} // namespace snapshot
-} // namespace android
-
-int main(int argc, char** argv) {
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
deleted file mode 100644
index 93bb0b2..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ /dev/null
@@ -1,870 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <dirent.h>
-#include <fcntl.h>
-#include <linux/fs.h>
-#include <unistd.h>
-#include <algorithm>
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <android-base/parseint.h>
-#include <android-base/properties.h>
-#include <android-base/strings.h>
-#include <android-base/unique_fd.h>
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-Snapuserd::Snapuserd(const std::string& misc_name, const std::string& cow_device,
- const std::string& backing_device) {
- misc_name_ = misc_name;
- cow_device_ = cow_device;
- backing_store_device_ = backing_device;
- control_device_ = "/dev/dm-user/" + misc_name;
-}
-
-bool Snapuserd::InitializeWorkers() {
- for (int i = 0; i < NUM_THREADS_PER_PARTITION; i++) {
- std::unique_ptr<WorkerThread> wt = std::make_unique<WorkerThread>(
- cow_device_, backing_store_device_, control_device_, misc_name_, GetSharedPtr());
-
- worker_threads_.push_back(std::move(wt));
- }
-
- read_ahead_thread_ = std::make_unique<ReadAheadThread>(cow_device_, backing_store_device_,
- misc_name_, GetSharedPtr());
- return true;
-}
-
-std::unique_ptr<CowReader> Snapuserd::CloneReaderForWorker() {
- return reader_->CloneCowReader();
-}
-
-bool Snapuserd::CommitMerge(int num_merge_ops) {
- struct CowHeader* ch = reinterpret_cast<struct CowHeader*>(mapped_addr_);
- ch->num_merge_ops += num_merge_ops;
-
- if (read_ahead_feature_ && read_ahead_ops_.size() > 0) {
- struct BufferState* ra_state = GetBufferState();
- ra_state->read_ahead_state = kCowReadAheadInProgress;
- }
-
- int ret = msync(mapped_addr_, BLOCK_SZ, MS_SYNC);
- if (ret < 0) {
- SNAP_PLOG(ERROR) << "msync header failed: " << ret;
- return false;
- }
-
- merge_initiated_ = true;
-
- return true;
-}
-
-void Snapuserd::PrepareReadAhead() {
- if (!read_ahead_feature_) {
- return;
- }
-
- struct BufferState* ra_state = GetBufferState();
- // Check if the data has to be re-constructed from COW device
- if (ra_state->read_ahead_state == kCowReadAheadDone) {
- populate_data_from_cow_ = true;
- } else {
- populate_data_from_cow_ = false;
- }
-
- StartReadAhead();
-}
-
-bool Snapuserd::GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t block, void* buffer) {
- if (!lock->owns_lock()) {
- SNAP_LOG(ERROR) << "GetRABuffer - Lock not held";
- return false;
- }
- std::unordered_map<uint64_t, void*>::iterator it = read_ahead_buffer_map_.find(block);
-
- // This will be true only for IO's generated as part of reading a root
- // filesystem. IO's related to merge should always be in read-ahead cache.
- if (it == read_ahead_buffer_map_.end()) {
- return false;
- }
-
- // Theoretically, we can send the data back from the read-ahead buffer
- // all the way to the kernel without memcpy. However, if the IO is
- // un-aligned, the wrapper function will need to touch the read-ahead
- // buffers and transitions will be bit more complicated.
- memcpy(buffer, it->second, BLOCK_SZ);
- return true;
-}
-
-// ========== State transition functions for read-ahead operations ===========
-
-bool Snapuserd::GetReadAheadPopulatedBuffer(uint64_t block, void* buffer) {
- if (!read_ahead_feature_) {
- return false;
- }
-
- {
- std::unique_lock<std::mutex> lock(lock_);
- if (io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE) {
- return false;
- }
-
- if (io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS) {
- return GetRABuffer(&lock, block, buffer);
- }
- }
-
- {
- // Read-ahead thread IO is in-progress. Wait for it to complete
- std::unique_lock<std::mutex> lock(lock_);
- while (!(io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE ||
- io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS)) {
- cv.wait(lock);
- }
-
- return GetRABuffer(&lock, block, buffer);
- }
-}
-
-// This is invoked by read-ahead thread waiting for merge IO's
-// to complete
-bool Snapuserd::WaitForMergeToComplete() {
- {
- std::unique_lock<std::mutex> lock(lock_);
- while (!(io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_BEGIN ||
- io_state_ == READ_AHEAD_IO_TRANSITION::IO_TERMINATED)) {
- cv.wait(lock);
- }
-
- if (io_state_ == READ_AHEAD_IO_TRANSITION::IO_TERMINATED) {
- return false;
- }
-
- io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_IN_PROGRESS;
- return true;
- }
-}
-
-// This is invoked during the launch of worker threads. We wait
-// for read-ahead thread to by fully up before worker threads
-// are launched; else we will have a race between worker threads
-// and read-ahead thread specifically during re-construction.
-bool Snapuserd::WaitForReadAheadToStart() {
- {
- std::unique_lock<std::mutex> lock(lock_);
- while (!(io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS ||
- io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE)) {
- cv.wait(lock);
- }
-
- if (io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE) {
- return false;
- }
-
- return true;
- }
-}
-
-// Invoked by worker threads when a sequence of merge operation
-// is complete notifying read-ahead thread to make forward
-// progress.
-void Snapuserd::StartReadAhead() {
- {
- std::lock_guard<std::mutex> lock(lock_);
- io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_BEGIN;
- }
-
- cv.notify_one();
-}
-
-void Snapuserd::MergeCompleted() {
- {
- std::lock_guard<std::mutex> lock(lock_);
- io_state_ = READ_AHEAD_IO_TRANSITION::IO_TERMINATED;
- }
-
- cv.notify_one();
-}
-
-bool Snapuserd::ReadAheadIOCompleted(bool sync) {
- if (sync) {
- // Flush the entire buffer region
- int ret = msync(mapped_addr_, total_mapped_addr_length_, MS_SYNC);
- if (ret < 0) {
- PLOG(ERROR) << "msync failed after ReadAheadIOCompleted: " << ret;
- return false;
- }
-
- // Metadata and data are synced. Now, update the state.
- // We need to update the state after flushing data; if there is a crash
- // when read-ahead IO is in progress, the state of data in the COW file
- // is unknown. kCowReadAheadDone acts as a checkpoint wherein the data
- // in the scratch space is good and during next reboot, read-ahead thread
- // can safely re-construct the data.
- struct BufferState* ra_state = GetBufferState();
- ra_state->read_ahead_state = kCowReadAheadDone;
-
- ret = msync(mapped_addr_, BLOCK_SZ, MS_SYNC);
- if (ret < 0) {
- PLOG(ERROR) << "msync failed to flush Readahead completion state...";
- return false;
- }
- }
-
- // Notify the worker threads
- {
- std::lock_guard<std::mutex> lock(lock_);
- io_state_ = READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS;
- }
-
- cv.notify_all();
- return true;
-}
-
-void Snapuserd::ReadAheadIOFailed() {
- {
- std::lock_guard<std::mutex> lock(lock_);
- io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE;
- }
-
- cv.notify_all();
-}
-
-//========== End of state transition functions ====================
-
-bool Snapuserd::IsChunkIdMetadata(chunk_t chunk) {
- uint32_t stride = exceptions_per_area_ + 1;
- lldiv_t divresult = lldiv(chunk, stride);
-
- return (divresult.rem == NUM_SNAPSHOT_HDR_CHUNKS);
-}
-
-// Find the next free chunk-id to be assigned. Check if the next free
-// chunk-id represents a metadata page. If so, skip it.
-chunk_t Snapuserd::GetNextAllocatableChunkId(chunk_t chunk) {
- chunk_t next_chunk = chunk + 1;
-
- if (IsChunkIdMetadata(next_chunk)) {
- next_chunk += 1;
- }
- return next_chunk;
-}
-
-void Snapuserd::CheckMergeCompletionStatus() {
- if (!merge_initiated_) {
- SNAP_LOG(INFO) << "Merge was not initiated. Total-data-ops: "
- << reader_->get_num_total_data_ops();
- return;
- }
-
- struct CowHeader* ch = reinterpret_cast<struct CowHeader*>(mapped_addr_);
-
- SNAP_LOG(INFO) << "Merge-status: Total-Merged-ops: " << ch->num_merge_ops
- << " Total-data-ops: " << reader_->get_num_total_data_ops();
-}
-
-/*
- * Read the metadata from COW device and
- * construct the metadata as required by the kernel.
- *
- * Please see design on kernel COW format
- *
- * 1: Read the metadata from internal COW device
- * 2: There are 3 COW operations:
- * a: Replace op
- * b: Copy op
- * c: Zero op
- * 3: For each of the 3 operations, op->new_block
- * represents the block number in the base device
- * for which one of the 3 operations have to be applied.
- * This represents the old_chunk in the kernel COW format
- * 4: We need to assign new_chunk for a corresponding old_chunk
- * 5: The algorithm is similar to how kernel assigns chunk number
- * while creating exceptions. However, there are few cases
- * which needs to be addressed here:
- * a: During merge process, kernel scans the metadata page
- * from backwards when merge is initiated. Since, we need
- * to make sure that the merge ordering follows our COW format,
- * we read the COW operation from backwards and populate the
- * metadata so that when kernel starts the merging from backwards,
- * those ops correspond to the beginning of our COW format.
- * b: Kernel can merge successive operations if the two chunk IDs
- * are contiguous. This can be problematic when there is a crash
- * during merge; specifically when the merge operation has dependency.
- * These dependencies can only happen during copy operations.
- *
- * To avoid this problem, we make sure overlap copy operations
- * are not batch merged.
- * 6: Use a monotonically increasing chunk number to assign the
- * new_chunk
- * 7: Each chunk-id represents either
- * a: Metadata page or
- * b: Data page
- * 8: Chunk-id representing a data page is stored in a map.
- * 9: Chunk-id representing a metadata page is converted into a vector
- * index. We store this in vector as kernel requests metadata during
- * two stage:
- * a: When initial dm-snapshot device is created, kernel requests
- * all the metadata and stores it in its internal data-structures.
- * b: During merge, kernel once again requests the same metadata
- * once-again.
- * In both these cases, a quick lookup based on chunk-id is done.
- * 10: When chunk number is incremented, we need to make sure that
- * if the chunk is representing a metadata page and skip.
- * 11: Each 4k page will contain 256 disk exceptions. We call this
- * exceptions_per_area_
- * 12: Kernel will stop issuing metadata IO request when new-chunk ID is 0.
- */
-bool Snapuserd::ReadMetadata() {
- reader_ = std::make_unique<CowReader>();
- CowOptions options;
- bool metadata_found = false;
- int replace_ops = 0, zero_ops = 0, copy_ops = 0;
-
- SNAP_LOG(DEBUG) << "ReadMetadata: Parsing cow file";
-
- if (!reader_->Parse(cow_fd_)) {
- SNAP_LOG(ERROR) << "Failed to parse";
- return false;
- }
-
- const auto& header = reader_->GetHeader();
- if (!(header.block_size == BLOCK_SZ)) {
- SNAP_LOG(ERROR) << "Invalid header block size found: " << header.block_size;
- return false;
- }
-
- SNAP_LOG(DEBUG) << "Merge-ops: " << header.num_merge_ops;
-
- if (!MmapMetadata()) {
- SNAP_LOG(ERROR) << "mmap failed";
- return false;
- }
-
- // Initialize the iterator for reading metadata
- std::unique_ptr<ICowOpIter> cowop_rm_iter = reader_->GetRevMergeOpIter();
-
- exceptions_per_area_ = (CHUNK_SIZE << SECTOR_SHIFT) / sizeof(struct disk_exception);
-
- // Start from chunk number 2. Chunk 0 represents header and chunk 1
- // represents first metadata page.
- chunk_t data_chunk_id = NUM_SNAPSHOT_HDR_CHUNKS + 1;
- size_t num_ops = 0;
-
- loff_t offset = 0;
- std::unique_ptr<uint8_t[]> de_ptr =
- std::make_unique<uint8_t[]>(exceptions_per_area_ * sizeof(struct disk_exception));
-
- // This memset is important. Kernel will stop issuing IO when new-chunk ID
- // is 0. When Area is not filled completely with all 256 exceptions,
- // this memset will ensure that metadata read is completed.
- memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
- while (!cowop_rm_iter->AtEnd()) {
- const CowOperation* cow_op = cowop_rm_iter->Get();
- struct disk_exception* de =
- reinterpret_cast<struct disk_exception*>((char*)de_ptr.get() + offset);
-
- metadata_found = true;
- // This loop will handle all the replace and zero ops.
- // We will handle the copy ops later as it requires special
- // handling of assigning chunk-id's. Furthermore, we make
- // sure that replace/zero and copy ops are not batch merged; hence,
- // the bump in the chunk_id before break of this loop
- if (IsOrderedOp(*cow_op)) {
- data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
- break;
- }
-
- if (cow_op->type() == kCowReplaceOp) {
- replace_ops++;
- } else if (cow_op->type() == kCowZeroOp) {
- zero_ops++;
- }
-
- // Construct the disk-exception
- de->old_chunk = cow_op->new_block;
- de->new_chunk = data_chunk_id;
-
- // Store operation pointer.
- chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
- num_ops += 1;
- offset += sizeof(struct disk_exception);
- cowop_rm_iter->Next();
-
- SNAP_LOG(DEBUG) << num_ops << ":"
- << " Old-chunk: " << de->old_chunk << " New-chunk: " << de->new_chunk;
-
- if (num_ops == exceptions_per_area_) {
- // Store it in vector at the right index. This maps the chunk-id to
- // vector index.
- vec_.push_back(std::move(de_ptr));
- offset = 0;
- num_ops = 0;
-
- // Create buffer for next area
- de_ptr = std::make_unique<uint8_t[]>(exceptions_per_area_ *
- sizeof(struct disk_exception));
- memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
- if (cowop_rm_iter->AtEnd()) {
- vec_.push_back(std::move(de_ptr));
- }
- }
-
- data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
- }
-
- int num_ra_ops_per_iter = ((GetBufferDataSize()) / BLOCK_SZ);
- std::optional<chunk_t> prev_id = {};
- std::vector<const CowOperation*> vec;
- std::set<uint64_t> dest_blocks;
- std::set<uint64_t> source_blocks;
- size_t pending_ordered_ops = exceptions_per_area_ - num_ops;
- uint64_t total_ordered_ops = reader_->get_num_ordered_ops_to_merge();
-
- SNAP_LOG(DEBUG) << " Processing copy-ops at Area: " << vec_.size()
- << " Number of replace/zero ops completed in this area: " << num_ops
- << " Pending copy ops for this area: " << pending_ordered_ops;
-
- while (!cowop_rm_iter->AtEnd()) {
- do {
- const CowOperation* cow_op = cowop_rm_iter->Get();
-
- // We have two cases specific cases:
- //
- // =====================================================
- // Case 1: Overlapping copy regions
- //
- // Ex:
- //
- // Source -> Destination
- //
- // 1: 15 -> 18
- // 2: 16 -> 19
- // 3: 17 -> 20
- // 4: 18 -> 21
- // 5: 19 -> 22
- // 6: 20 -> 23
- //
- // We have 6 copy operations to be executed in OTA and there is a overlap. Update-engine
- // will write to COW file as follows:
- //
- // Op-1: 20 -> 23
- // Op-2: 19 -> 22
- // Op-3: 18 -> 21
- // Op-4: 17 -> 20
- // Op-5: 16 -> 19
- // Op-6: 15 -> 18
- //
- // Note that the blocks numbers are contiguous. Hence, all 6 copy
- // operations can be batch merged. However, that will be
- // problematic if we have a crash as block 20, 19, 18 would have
- // been overwritten and hence subsequent recovery may end up with
- // a silent data corruption when op-1, op-2 and op-3 are
- // re-executed.
- //
- // To address the above problem, read-ahead thread will
- // read all the 6 source blocks, cache them in the scratch
- // space of the COW file. During merge, read-ahead
- // thread will serve the blocks from the read-ahead cache.
- // If there is a crash during merge; on subsequent reboot,
- // read-ahead thread will recover the data from the
- // scratch space and re-construct it thereby there
- // is no loss of data.
- //
- // Note that we will follow the same order of COW operations
- // as present in the COW file. This will make sure that
- // the merge of operations are done based on the ops present
- // in the file.
- //===========================================================
- uint64_t block_source = cow_op->source();
- if (prev_id.has_value()) {
- if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {
- break;
- }
- }
- metadata_found = true;
- pending_ordered_ops -= 1;
- vec.push_back(cow_op);
- dest_blocks.insert(block_source);
- source_blocks.insert(cow_op->new_block);
- prev_id = cow_op->new_block;
- cowop_rm_iter->Next();
- } while (!cowop_rm_iter->AtEnd() && pending_ordered_ops);
-
- data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
- SNAP_LOG(DEBUG) << "Batch Merge copy-ops of size: " << vec.size()
- << " Area: " << vec_.size() << " Area offset: " << offset
- << " Pending-ordered-ops in this area: " << pending_ordered_ops;
-
- for (size_t i = 0; i < vec.size(); i++) {
- struct disk_exception* de =
- reinterpret_cast<struct disk_exception*>((char*)de_ptr.get() + offset);
- const CowOperation* cow_op = vec[i];
-
- de->old_chunk = cow_op->new_block;
- de->new_chunk = data_chunk_id;
-
- // Store operation pointer.
- chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
- offset += sizeof(struct disk_exception);
- num_ops += 1;
- if (cow_op->type() == kCowCopyOp) {
- copy_ops++;
- }
-
- if (read_ahead_feature_) {
- read_ahead_ops_.push_back(cow_op);
- }
-
- SNAP_LOG(DEBUG) << num_ops << ":"
- << " Ordered-op: "
- << " Old-chunk: " << de->old_chunk << " New-chunk: " << de->new_chunk;
-
- if (num_ops == exceptions_per_area_) {
- // Store it in vector at the right index. This maps the chunk-id to
- // vector index.
- vec_.push_back(std::move(de_ptr));
- num_ops = 0;
- offset = 0;
-
- // Create buffer for next area
- de_ptr = std::make_unique<uint8_t[]>(exceptions_per_area_ *
- sizeof(struct disk_exception));
- memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
- if (cowop_rm_iter->AtEnd()) {
- vec_.push_back(std::move(de_ptr));
- SNAP_LOG(DEBUG) << "ReadMetadata() completed; Number of Areas: " << vec_.size();
- }
-
- if (!(pending_ordered_ops == 0)) {
- SNAP_LOG(ERROR) << "Invalid pending_ordered_ops: expected: 0 found: "
- << pending_ordered_ops;
- return false;
- }
- pending_ordered_ops = exceptions_per_area_;
- }
-
- data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
- total_ordered_ops -= 1;
- /*
- * Split the number of ops based on the size of read-ahead buffer
- * region. We need to ensure that kernel doesn't issue IO on blocks
- * which are not read by the read-ahead thread.
- */
- if (read_ahead_feature_ && (total_ordered_ops % num_ra_ops_per_iter == 0)) {
- data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
- }
- }
- vec.clear();
- dest_blocks.clear();
- source_blocks.clear();
- prev_id.reset();
- }
-
- // Partially filled area or there is no metadata
- // If there is no metadata, fill with zero so that kernel
- // is aware that merge is completed.
- if (num_ops || !metadata_found) {
- vec_.push_back(std::move(de_ptr));
- SNAP_LOG(DEBUG) << "ReadMetadata() completed. Partially filled area num_ops: " << num_ops
- << "Areas : " << vec_.size();
- }
-
- chunk_vec_.shrink_to_fit();
- vec_.shrink_to_fit();
- read_ahead_ops_.shrink_to_fit();
-
- // Sort the vector based on sectors as we need this during un-aligned access
- std::sort(chunk_vec_.begin(), chunk_vec_.end(), compare);
-
- SNAP_LOG(INFO) << "ReadMetadata completed. Final-chunk-id: " << data_chunk_id
- << " Num Sector: " << ChunkToSector(data_chunk_id)
- << " Replace-ops: " << replace_ops << " Zero-ops: " << zero_ops
- << " Copy-ops: " << copy_ops << " Areas: " << vec_.size()
- << " Num-ops-merged: " << header.num_merge_ops
- << " Total-data-ops: " << reader_->get_num_total_data_ops();
-
- // Total number of sectors required for creating dm-user device
- num_sectors_ = ChunkToSector(data_chunk_id);
- merge_initiated_ = false;
- PrepareReadAhead();
-
- return true;
-}
-
-bool Snapuserd::MmapMetadata() {
- const auto& header = reader_->GetHeader();
-
- if (header.prefix.major_version >= 2 && header.buffer_size > 0) {
- total_mapped_addr_length_ = header.prefix.header_size + BUFFER_REGION_DEFAULT_SIZE;
- read_ahead_feature_ = true;
- } else {
- // mmap the first 4k page - older COW format
- total_mapped_addr_length_ = BLOCK_SZ;
- read_ahead_feature_ = false;
- }
-
- mapped_addr_ = mmap(NULL, total_mapped_addr_length_, PROT_READ | PROT_WRITE, MAP_SHARED,
- cow_fd_.get(), 0);
- if (mapped_addr_ == MAP_FAILED) {
- SNAP_LOG(ERROR) << "mmap metadata failed";
- return false;
- }
-
- return true;
-}
-
-void Snapuserd::UnmapBufferRegion() {
- int ret = munmap(mapped_addr_, total_mapped_addr_length_);
- if (ret < 0) {
- SNAP_PLOG(ERROR) << "munmap failed";
- }
-}
-
-void MyLogger(android::base::LogId, android::base::LogSeverity severity, const char*, const char*,
- unsigned int, const char* message) {
- if (severity == android::base::ERROR) {
- fprintf(stderr, "%s\n", message);
- } else {
- fprintf(stdout, "%s\n", message);
- }
-}
-
-bool Snapuserd::InitCowDevice() {
- cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
- if (cow_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
- return false;
- }
-
- return ReadMetadata();
-}
-
-void Snapuserd::ReadBlocksToCache(const std::string& dm_block_device,
- const std::string& partition_name, off_t offset, size_t size) {
- android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY)));
- if (fd.get() == -1) {
- SNAP_PLOG(ERROR) << "Error reading " << dm_block_device
- << " partition-name: " << partition_name;
- return;
- }
-
- size_t remain = size;
- off_t file_offset = offset;
- // We pick 4M I/O size based on the fact that the current
- // update_verifier has a similar I/O size.
- size_t read_sz = 1024 * BLOCK_SZ;
- std::vector<uint8_t> buf(read_sz);
-
- while (remain > 0) {
- size_t to_read = std::min(remain, read_sz);
-
- if (!android::base::ReadFullyAtOffset(fd.get(), buf.data(), to_read, file_offset)) {
- SNAP_PLOG(ERROR) << "Failed to read block from block device: " << dm_block_device
- << " at offset: " << file_offset
- << " partition-name: " << partition_name << " total-size: " << size
- << " remain_size: " << remain;
- return;
- }
-
- file_offset += to_read;
- remain -= to_read;
- }
-
- SNAP_LOG(INFO) << "Finished reading block-device: " << dm_block_device
- << " partition: " << partition_name << " size: " << size
- << " offset: " << offset;
-}
-
-void Snapuserd::ReadBlocks(const std::string& partition_name, const std::string& dm_block_device) {
- SNAP_LOG(DEBUG) << "Reading partition: " << partition_name
- << " Block-Device: " << dm_block_device;
-
- uint64_t dev_sz = 0;
-
- unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY | O_CLOEXEC)));
- if (fd < 0) {
- SNAP_LOG(ERROR) << "Cannot open block device";
- return;
- }
-
- dev_sz = get_block_device_size(fd.get());
- if (!dev_sz) {
- SNAP_PLOG(ERROR) << "Could not determine block device size: " << dm_block_device;
- return;
- }
-
- int num_threads = 2;
- size_t num_blocks = dev_sz >> BLOCK_SHIFT;
- size_t num_blocks_per_thread = num_blocks / num_threads;
- size_t read_sz_per_thread = num_blocks_per_thread << BLOCK_SHIFT;
- off_t offset = 0;
-
- for (int i = 0; i < num_threads; i++) {
- (void)std::async(std::launch::async, &Snapuserd::ReadBlocksToCache, this, dm_block_device,
- partition_name, offset, read_sz_per_thread);
-
- offset += read_sz_per_thread;
- }
-}
-
-/*
- * Entry point to launch threads
- */
-bool Snapuserd::Start() {
- std::vector<std::future<bool>> threads;
- std::future<bool> ra_thread;
- bool rathread = (read_ahead_feature_ && (read_ahead_ops_.size() > 0));
-
- // Start the read-ahead thread and wait
- // for it as the data has to be re-constructed
- // from COW device.
- if (rathread) {
- ra_thread = std::async(std::launch::async, &ReadAheadThread::RunThread,
- read_ahead_thread_.get());
- if (!WaitForReadAheadToStart()) {
- SNAP_LOG(ERROR) << "Failed to start Read-ahead thread...";
- return false;
- }
-
- SNAP_LOG(INFO) << "Read-ahead thread started...";
- }
-
- // Launch worker threads
- for (int i = 0; i < worker_threads_.size(); i++) {
- threads.emplace_back(
- std::async(std::launch::async, &WorkerThread::RunThread, worker_threads_[i].get()));
- }
-
- bool second_stage_init = true;
-
- // We don't want to read the blocks during first stage init.
- if (android::base::EndsWith(misc_name_, "-init") || is_socket_present_) {
- second_stage_init = false;
- }
-
- if (second_stage_init) {
- SNAP_LOG(INFO) << "Reading blocks to cache....";
- auto& dm = DeviceMapper::Instance();
- auto dm_block_devices = dm.FindDmPartitions();
- if (dm_block_devices.empty()) {
- SNAP_LOG(ERROR) << "No dm-enabled block device is found.";
- } else {
- auto parts = android::base::Split(misc_name_, "-");
- std::string partition_name = parts[0];
-
- const char* suffix_b = "_b";
- const char* suffix_a = "_a";
-
- partition_name.erase(partition_name.find_last_not_of(suffix_b) + 1);
- partition_name.erase(partition_name.find_last_not_of(suffix_a) + 1);
-
- if (dm_block_devices.find(partition_name) == dm_block_devices.end()) {
- SNAP_LOG(ERROR) << "Failed to find dm block device for " << partition_name;
- } else {
- ReadBlocks(partition_name, dm_block_devices.at(partition_name));
- }
- }
- } else {
- SNAP_LOG(INFO) << "Not reading block device into cache";
- }
-
- bool ret = true;
- for (auto& t : threads) {
- ret = t.get() && ret;
- }
-
- if (rathread) {
- // Notify the read-ahead thread that all worker threads
- // are done. We need this explicit notification when
- // there is an IO failure or there was a switch
- // of dm-user table; thus, forcing the read-ahead
- // thread to wake up.
- MergeCompleted();
- ret = ret && ra_thread.get();
- }
-
- return ret;
-}
-
-uint64_t Snapuserd::GetBufferMetadataOffset() {
- const auto& header = reader_->GetHeader();
-
- size_t size = header.prefix.header_size + sizeof(BufferState);
- return size;
-}
-
-/*
- * Metadata for read-ahead is 16 bytes. For a 2 MB region, we will
- * end up with 8k (2 PAGE) worth of metadata. Thus, a 2MB buffer
- * region is split into:
- *
- * 1: 8k metadata
- *
- */
-size_t Snapuserd::GetBufferMetadataSize() {
- const auto& header = reader_->GetHeader();
-
- size_t metadata_bytes = (header.buffer_size * sizeof(struct ScratchMetadata)) / BLOCK_SZ;
- return metadata_bytes;
-}
-
-size_t Snapuserd::GetBufferDataOffset() {
- const auto& header = reader_->GetHeader();
-
- return (header.prefix.header_size + GetBufferMetadataSize());
-}
-
-/*
- * (2MB - 8K = 2088960 bytes) will be the buffer region to hold the data.
- */
-size_t Snapuserd::GetBufferDataSize() {
- const auto& header = reader_->GetHeader();
-
- size_t size = header.buffer_size - GetBufferMetadataSize();
- return size;
-}
-
-struct BufferState* Snapuserd::GetBufferState() {
- const auto& header = reader_->GetHeader();
-
- struct BufferState* ra_state =
- reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.prefix.header_size);
- return ra_state;
-}
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h
deleted file mode 100644
index beb6004..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h
+++ /dev/null
@@ -1,332 +0,0 @@
-// Copyright (C) 2020 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 <linux/types.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-
-#include <bitset>
-#include <condition_variable>
-#include <csignal>
-#include <cstring>
-#include <future>
-#include <iostream>
-#include <limits>
-#include <map>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
-#include <ext4_utils/ext4_utils.h>
-#include <libdm/dm.h>
-#include <libsnapshot/cow_reader.h>
-#include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_buffer.h>
-#include <snapuserd/snapuserd_kernel.h>
-
-namespace android {
-namespace snapshot {
-
-using android::base::unique_fd;
-using namespace std::chrono_literals;
-
-static constexpr size_t PAYLOAD_SIZE = (1UL << 20);
-static_assert(PAYLOAD_SIZE >= BLOCK_SZ);
-
-/*
- * With 4 threads, we get optimal performance
- * when update_verifier reads the partition during
- * boot.
- */
-static constexpr int NUM_THREADS_PER_PARTITION = 4;
-
-/*
- * State transitions between worker threads and read-ahead
- * threads.
- *
- * READ_AHEAD_BEGIN: Worker threads initiates the read-ahead
- * thread to begin reading the copy operations
- * for each bounded region.
- *
- * READ_AHEAD_IN_PROGRESS: When read ahead thread is in-flight
- * and reading the copy operations.
- *
- * IO_IN_PROGRESS: Merge operation is in-progress by worker threads.
- *
- * IO_TERMINATED: When all the worker threads are done, request the
- * read-ahead thread to terminate
- *
- * READ_AHEAD_FAILURE: If there are any IO failures when read-ahead
- * thread is reading from COW device.
- *
- * The transition of each states is described in snapuserd_readahead.cpp
- */
-enum class READ_AHEAD_IO_TRANSITION {
- READ_AHEAD_BEGIN,
- READ_AHEAD_IN_PROGRESS,
- IO_IN_PROGRESS,
- IO_TERMINATED,
- READ_AHEAD_FAILURE,
-};
-
-class Snapuserd;
-
-class ReadAheadThread {
- public:
- ReadAheadThread(const std::string& cow_device, const std::string& backing_device,
- const std::string& misc_name, std::shared_ptr<Snapuserd> snapuserd);
- bool RunThread();
-
- private:
- void InitializeRAIter();
- bool RAIterDone();
- void RAIterNext();
- const CowOperation* GetRAOpIter();
- void InitializeBuffer();
-
- bool InitializeFds();
- void CloseFds() {
- cow_fd_ = {};
- backing_store_fd_ = {};
- }
-
- bool ReadAheadIOStart();
- void PrepareReadAhead(uint64_t* source_offset, int* pending_ops, std::vector<uint64_t>& blocks);
- bool ReconstructDataFromCow();
- void CheckOverlap(const CowOperation* cow_op);
-
- void* read_ahead_buffer_;
- void* metadata_buffer_;
- std::vector<const CowOperation*>::reverse_iterator read_ahead_iter_;
- std::string cow_device_;
- std::string backing_store_device_;
- std::string misc_name_;
-
- unique_fd cow_fd_;
- unique_fd backing_store_fd_;
-
- std::shared_ptr<Snapuserd> snapuserd_;
-
- std::unordered_set<uint64_t> dest_blocks_;
- std::unordered_set<uint64_t> source_blocks_;
- bool overlap_;
-};
-
-class WorkerThread {
- public:
- WorkerThread(const std::string& cow_device, const std::string& backing_device,
- const std::string& control_device, const std::string& misc_name,
- std::shared_ptr<Snapuserd> snapuserd);
- bool RunThread();
-
- private:
- // Initialization
- void InitializeBufsink();
- bool InitializeFds();
- bool InitReader();
- void CloseFds() {
- ctrl_fd_ = {};
- backing_store_fd_ = {};
- }
-
- // Functions interacting with dm-user
- bool ReadDmUserHeader();
- bool DmuserReadRequest();
- bool DmuserWriteRequest();
- bool ReadDmUserPayload(void* buffer, size_t size);
- bool WriteDmUserPayload(size_t size, bool header_response);
-
- bool ReadDiskExceptions(chunk_t chunk, size_t size);
- bool ZerofillDiskExceptions(size_t read_size);
- void ConstructKernelCowHeader();
-
- // IO Path
- bool ProcessIORequest();
- int ReadData(sector_t sector, size_t size);
- int ReadUnalignedSector(sector_t sector, size_t size,
- std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-
- // Processing COW operations
- bool ProcessCowOp(const CowOperation* cow_op);
- bool ProcessReplaceOp(const CowOperation* cow_op);
- // Handles Copy
- bool ProcessCopyOp(const CowOperation* cow_op);
- bool ProcessZeroOp();
-
- bool ReadFromBaseDevice(const CowOperation* cow_op);
- bool GetReadAheadPopulatedBuffer(const CowOperation* cow_op);
-
- // Merge related functions
- bool ProcessMergeComplete(chunk_t chunk, void* buffer);
- loff_t GetMergeStartOffset(void* merged_buffer, void* unmerged_buffer,
- int* unmerged_exceptions);
-
- int GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffer, loff_t offset,
- int unmerged_exceptions, bool* copy_op, bool* commit);
-
- sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
- chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-
- std::unique_ptr<CowReader> reader_;
- BufferSink bufsink_;
-
- std::string cow_device_;
- std::string backing_store_device_;
- std::string control_device_;
- std::string misc_name_;
-
- unique_fd cow_fd_;
- unique_fd backing_store_fd_;
- unique_fd ctrl_fd_;
-
- std::shared_ptr<Snapuserd> snapuserd_;
- uint32_t exceptions_per_area_;
-};
-
-class Snapuserd : public std::enable_shared_from_this<Snapuserd> {
- public:
- Snapuserd(const std::string& misc_name, const std::string& cow_device,
- const std::string& backing_device);
- bool InitCowDevice();
- bool Start();
- const std::string& GetControlDevicePath() { return control_device_; }
- const std::string& GetMiscName() { return misc_name_; }
- uint64_t GetNumSectors() { return num_sectors_; }
- bool IsAttached() const { return attached_; }
- void AttachControlDevice() { attached_ = true; }
-
- void CheckMergeCompletionStatus();
- bool CommitMerge(int num_merge_ops);
-
- void CloseFds() { cow_fd_ = {}; }
- void FreeResources() {
- worker_threads_.clear();
- read_ahead_thread_ = nullptr;
- }
- size_t GetMetadataAreaSize() { return vec_.size(); }
- void* GetExceptionBuffer(size_t i) { return vec_[i].get(); }
-
- bool InitializeWorkers();
- std::unique_ptr<CowReader> CloneReaderForWorker();
- std::shared_ptr<Snapuserd> GetSharedPtr() { return shared_from_this(); }
-
- std::vector<std::pair<sector_t, const CowOperation*>>& GetChunkVec() { return chunk_vec_; }
- const std::vector<std::unique_ptr<uint8_t[]>>& GetMetadataVec() const { return vec_; }
-
- static bool compare(std::pair<sector_t, const CowOperation*> p1,
- std::pair<sector_t, const CowOperation*> p2) {
- return p1.first < p2.first;
- }
-
- void UnmapBufferRegion();
- bool MmapMetadata();
-
- // Read-ahead related functions
- std::vector<const CowOperation*>& GetReadAheadOpsVec() { return read_ahead_ops_; }
- std::unordered_map<uint64_t, void*>& GetReadAheadMap() { return read_ahead_buffer_map_; }
- void* GetMappedAddr() { return mapped_addr_; }
- bool IsReadAheadFeaturePresent() { return read_ahead_feature_; }
- void PrepareReadAhead();
- void StartReadAhead();
- void MergeCompleted();
- bool ReadAheadIOCompleted(bool sync);
- void ReadAheadIOFailed();
- bool WaitForMergeToComplete();
- bool GetReadAheadPopulatedBuffer(uint64_t block, void* buffer);
- bool ReconstructDataFromCow() { return populate_data_from_cow_; }
- void ReconstructDataFromCowFinish() { populate_data_from_cow_ = false; }
- bool WaitForReadAheadToStart();
-
- uint64_t GetBufferMetadataOffset();
- size_t GetBufferMetadataSize();
- size_t GetBufferDataOffset();
- size_t GetBufferDataSize();
-
- // Final block to be merged in a given read-ahead buffer region
- void SetFinalBlockMerged(uint64_t x) { final_block_merged_ = x; }
- uint64_t GetFinalBlockMerged() { return final_block_merged_; }
- // Total number of blocks to be merged in a given read-ahead buffer region
- void SetTotalRaBlocksMerged(int x) { total_ra_blocks_merged_ = x; }
- int GetTotalRaBlocksMerged() { return total_ra_blocks_merged_; }
- void SetSocketPresent(bool socket) { is_socket_present_ = socket; }
-
- private:
- bool IsChunkIdMetadata(chunk_t chunk);
- chunk_t GetNextAllocatableChunkId(chunk_t chunk_id);
-
- bool GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t block, void* buffer);
- bool ReadMetadata();
- sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
- chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
- bool IsBlockAligned(int read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
- struct BufferState* GetBufferState();
-
- void ReadBlocks(const std::string& partition_name, const std::string& dm_block_device);
- void ReadBlocksToCache(const std::string& dm_block_device, const std::string& partition_name,
- off_t offset, size_t size);
-
- std::string cow_device_;
- std::string backing_store_device_;
- std::string control_device_;
- std::string misc_name_;
-
- unique_fd cow_fd_;
-
- uint32_t exceptions_per_area_;
- uint64_t num_sectors_;
-
- std::unique_ptr<CowReader> reader_;
-
- // Vector of disk exception which is a
- // mapping of old-chunk to new-chunk
- std::vector<std::unique_ptr<uint8_t[]>> vec_;
-
- // chunk_vec stores the pseudo mapping of sector
- // to COW operations.
- std::vector<std::pair<sector_t, const CowOperation*>> chunk_vec_;
-
- std::mutex lock_;
- std::condition_variable cv;
-
- void* mapped_addr_;
- size_t total_mapped_addr_length_;
-
- std::vector<std::unique_ptr<WorkerThread>> worker_threads_;
- // Read-ahead related
- std::unordered_map<uint64_t, void*> read_ahead_buffer_map_;
- std::vector<const CowOperation*> read_ahead_ops_;
- bool populate_data_from_cow_ = false;
- bool read_ahead_feature_;
- uint64_t final_block_merged_;
- int total_ra_blocks_merged_ = 0;
- READ_AHEAD_IO_TRANSITION io_state_;
- std::unique_ptr<ReadAheadThread> read_ahead_thread_;
-
- bool merge_initiated_ = false;
- bool attached_ = false;
- bool is_socket_present_;
-};
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
deleted file mode 100644
index f1b9245..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ /dev/null
@@ -1,482 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-/*
- * Merging a copy operation involves the following flow:
- *
- * 1: dm-snapshot layer requests merge for a 4k block. dm-user sends the request
- * to the daemon
- * 2: daemon reads the source block
- * 3: daemon copies the source data
- * 4: IO completion sent back to dm-user (a switch from user space to kernel)
- * 5: dm-snapshot merges the data to base device
- * 6: dm-snapshot sends the merge-completion IO to dm-user
- * 7: dm-user re-directs the merge completion IO to daemon (one more switch)
- * 8: daemon updates the COW file about the completed merge request (a write syscall) and followed
- * by a fysnc. 9: Send the IO completion back to dm-user
- *
- * The above sequence is a significant overhead especially when merging one 4k
- * block at a time.
- *
- * Read-ahead layer will optimize the above path by reading the data from base
- * device in the background so that merging thread can retrieve the data from
- * the read-ahead cache. Additionally, syncing of merged data is deferred to
- * read-ahead thread threadby the IO path is not bottlenecked.
- *
- * We create a scratch space of 2MB to store the read-ahead data in the COW
- * device.
- *
- * +-----------------------+
- * | Header (fixed) |
- * +-----------------------+
- * | Scratch space | <-- 2MB
- * +-----------------------+
- *
- * Scratch space is as follows:
- *
- * +-----------------------+
- * | Metadata | <- 4k page
- * +-----------------------+
- * | Metadata | <- 4k page
- * +-----------------------+
- * | |
- * | Read-ahead data |
- * | |
- * +-----------------------+
- *
- * State transitions and communication between read-ahead thread and worker
- * thread during merge:
- * =====================================================================
- *
- * Worker Threads Read-Ahead thread
- * ------------------------------------------------------------------
- *
- * |
- * |
- * --> -----------------READ_AHEAD_BEGIN------------->|
- * | | | READ_AHEAD_IN_PROGRESS
- * | WAIT |
- * | | |
- * | |<-----------------IO_IN_PROGRESS---------------
- * | | |
- * | | IO_IN_PRGRESS WAIT
- * | | |
- * |<--| |
- * | |
- * ------------------IO_TERMINATED--------------->|
- * END
- *
- *
- * ===================================================================
- *
- * Example:
- *
- * We have 6 copy operations to be executed in OTA and there is a overlap. Update-engine
- * will write to COW file as follows:
- *
- * Op-1: 20 -> 23
- * Op-2: 19 -> 22
- * Op-3: 18 -> 21
- * Op-4: 17 -> 20
- * Op-5: 16 -> 19
- * Op-6: 15 -> 18
- *
- * Read-ahead thread will read all the 6 source blocks and store the data in the
- * scratch space. Metadata will contain the destination block numbers. Thus,
- * scratch space will look something like this:
- *
- * +--------------+
- * | Block 23 |
- * | offset - 1 |
- * +--------------+
- * | Block 22 |
- * | offset - 2 |
- * +--------------+
- * | Block 21 |
- * | offset - 3 |
- * +--------------+
- * ...
- * ...
- * +--------------+
- * | Data-Block 20| <-- offset - 1
- * +--------------+
- * | Data-Block 19| <-- offset - 2
- * +--------------+
- * | Data-Block 18| <-- offset - 3
- * +--------------+
- * ...
- * ...
- *
- * ====================================================================
- * IO Path:
- *
- * Read-ahead will serve the data to worker threads during merge only
- * after metadata and data are persisted to the scratch space. Worker
- * threads during merge will always retrieve the data from cache; if the
- * cache is not populated, it will wait for the read-ahead thread to finish.
- * Furthermore, the number of operations merged will by synced to the header
- * only when all the blocks in the read-ahead cache are merged. In the above
- * case, when all 6 operations are merged, COW Header is updated with
- * num_merge_ops = 6.
- *
- * Merge resume after crash:
- *
- * Let's say we have a crash after 5 operations are merged. i.e. after
- * Op-5: 16->19 is completed but before the Op-6 is merged. Thus, COW Header
- * num_merge_ops will be 0 as the all the ops were not merged yet. During next
- * reboot, read-ahead thread will re-construct the data in-memory from the
- * scratch space; when merge resumes, Op-1 will be re-exectued. However,
- * data will be served from read-ahead cache safely even though, block 20
- * was over-written by Op-4.
- *
- */
-
-ReadAheadThread::ReadAheadThread(const std::string& cow_device, const std::string& backing_device,
- const std::string& misc_name,
- std::shared_ptr<Snapuserd> snapuserd) {
- cow_device_ = cow_device;
- backing_store_device_ = backing_device;
- misc_name_ = misc_name;
- snapuserd_ = snapuserd;
-}
-
-void ReadAheadThread::CheckOverlap(const CowOperation* cow_op) {
- uint64_t source_block = cow_op->source();
- if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block)) {
- overlap_ = true;
- }
-
- dest_blocks_.insert(source_block);
- source_blocks_.insert(cow_op->new_block);
-}
-
-void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops,
- std::vector<uint64_t>& blocks) {
- int num_ops = *pending_ops;
- int nr_consecutive = 0;
- CHECK_NE(source_offset, nullptr);
-
- if (!RAIterDone() && num_ops) {
- // Get the first block with offset
- const CowOperation* cow_op = GetRAOpIter();
- CHECK_NE(cow_op, nullptr);
- *source_offset = cow_op->source();
- if (cow_op->type() == kCowCopyOp) {
- *source_offset *= BLOCK_SZ;
- }
- RAIterNext();
- num_ops -= 1;
- nr_consecutive = 1;
- blocks.push_back(cow_op->new_block);
-
- if (!overlap_) {
- CheckOverlap(cow_op);
- }
-
- /*
- * Find number of consecutive blocks working backwards.
- */
- while (!RAIterDone() && num_ops) {
- const CowOperation* op = GetRAOpIter();
- CHECK_NE(op, nullptr);
- uint64_t next_offset = op->source();
- if (op->type() == kCowCopyOp) {
- next_offset *= BLOCK_SZ;
- }
- if (next_offset + nr_consecutive * BLOCK_SZ != *source_offset) {
- break;
- }
- nr_consecutive += 1;
- num_ops -= 1;
- blocks.push_back(op->new_block);
- RAIterNext();
-
- if (!overlap_) {
- CheckOverlap(op);
- }
- }
- }
-}
-
-bool ReadAheadThread::ReconstructDataFromCow() {
- std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
- read_ahead_buffer_map.clear();
- loff_t metadata_offset = 0;
- loff_t start_data_offset = snapuserd_->GetBufferDataOffset();
- int num_ops = 0;
- int total_blocks_merged = 0;
-
- // This memcpy is important as metadata_buffer_ will be an unaligned address and will fault
- // on 32-bit systems
- std::unique_ptr<uint8_t[]> metadata_buffer =
- std::make_unique<uint8_t[]>(snapuserd_->GetBufferMetadataSize());
- memcpy(metadata_buffer.get(), metadata_buffer_, snapuserd_->GetBufferMetadataSize());
-
- while (true) {
- struct ScratchMetadata* bm = reinterpret_cast<struct ScratchMetadata*>(
- (char*)metadata_buffer.get() + metadata_offset);
-
- // Done reading metadata
- if (bm->new_block == 0 && bm->file_offset == 0) {
- break;
- }
-
- loff_t buffer_offset = bm->file_offset - start_data_offset;
- void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + buffer_offset);
- read_ahead_buffer_map[bm->new_block] = bufptr;
- num_ops += 1;
- total_blocks_merged += 1;
-
- metadata_offset += sizeof(struct ScratchMetadata);
- }
-
- // We are done re-constructing the mapping; however, we need to make sure
- // all the COW operations to-be merged are present in the re-constructed
- // mapping.
- while (!RAIterDone()) {
- const CowOperation* op = GetRAOpIter();
- if (read_ahead_buffer_map.find(op->new_block) != read_ahead_buffer_map.end()) {
- num_ops -= 1;
- snapuserd_->SetFinalBlockMerged(op->new_block);
- RAIterNext();
- } else {
- // Verify that we have covered all the ops which were re-constructed
- // from COW device - These are the ops which are being
- // re-constructed after crash.
- if (!(num_ops == 0)) {
- SNAP_LOG(ERROR) << "ReconstructDataFromCow failed. Not all ops recoverd "
- << " Pending ops: " << num_ops;
- snapuserd_->ReadAheadIOFailed();
- return false;
- }
- break;
- }
- }
-
- snapuserd_->SetTotalRaBlocksMerged(total_blocks_merged);
-
- snapuserd_->ReconstructDataFromCowFinish();
-
- if (!snapuserd_->ReadAheadIOCompleted(true)) {
- SNAP_LOG(ERROR) << "ReadAheadIOCompleted failed...";
- snapuserd_->ReadAheadIOFailed();
- return false;
- }
-
- SNAP_LOG(INFO) << "ReconstructDataFromCow success";
- return true;
-}
-
-bool ReadAheadThread::ReadAheadIOStart() {
- // Check if the data has to be constructed from the COW file.
- // This will be true only once during boot up after a crash
- // during merge.
- if (snapuserd_->ReconstructDataFromCow()) {
- return ReconstructDataFromCow();
- }
-
- std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
- read_ahead_buffer_map.clear();
-
- int num_ops = (snapuserd_->GetBufferDataSize()) / BLOCK_SZ;
- loff_t metadata_offset = 0;
-
- struct ScratchMetadata* bm =
- reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ + metadata_offset);
-
- bm->new_block = 0;
- bm->file_offset = 0;
-
- std::vector<uint64_t> blocks;
-
- loff_t buffer_offset = 0;
- loff_t offset = 0;
- loff_t file_offset = snapuserd_->GetBufferDataOffset();
- int total_blocks_merged = 0;
- overlap_ = false;
- dest_blocks_.clear();
- source_blocks_.clear();
-
- while (true) {
- uint64_t source_offset;
- int linear_blocks;
-
- PrepareReadAhead(&source_offset, &num_ops, blocks);
- linear_blocks = blocks.size();
- if (linear_blocks == 0) {
- // No more blocks to read
- SNAP_LOG(DEBUG) << " Read-ahead completed....";
- break;
- }
-
- // Get the first block in the consecutive set of blocks
- source_offset = source_offset - (linear_blocks - 1) * BLOCK_SZ;
- size_t io_size = (linear_blocks * BLOCK_SZ);
- num_ops -= linear_blocks;
- total_blocks_merged += linear_blocks;
-
- // Mark the block number as the one which will
- // be the final block to be merged in this entire region.
- // Read-ahead thread will get
- // notified when this block is merged to make
- // forward progress
- snapuserd_->SetFinalBlockMerged(blocks.back());
-
- while (linear_blocks) {
- uint64_t new_block = blocks.back();
- blocks.pop_back();
- // Assign the mapping
- void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + offset);
- read_ahead_buffer_map[new_block] = bufptr;
- offset += BLOCK_SZ;
-
- bm = reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ +
- metadata_offset);
- bm->new_block = new_block;
- bm->file_offset = file_offset;
-
- metadata_offset += sizeof(struct ScratchMetadata);
- file_offset += BLOCK_SZ;
-
- linear_blocks -= 1;
- }
-
- // Read from the base device consecutive set of blocks in one shot
- if (!android::base::ReadFullyAtOffset(backing_store_fd_,
- (char*)read_ahead_buffer_ + buffer_offset, io_size,
- source_offset)) {
- SNAP_PLOG(ERROR) << "Ordered-op failed. Read from backing store: "
- << backing_store_device_ << "at block :" << source_offset / BLOCK_SZ
- << " offset :" << source_offset % BLOCK_SZ
- << " buffer_offset : " << buffer_offset << " io_size : " << io_size
- << " buf-addr : " << read_ahead_buffer_;
-
- snapuserd_->ReadAheadIOFailed();
- return false;
- }
-
- // This is important - explicitly set the contents to zero. This is used
- // when re-constructing the data after crash. This indicates end of
- // reading metadata contents when re-constructing the data
- bm = reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ + metadata_offset);
- bm->new_block = 0;
- bm->file_offset = 0;
-
- buffer_offset += io_size;
- }
-
- snapuserd_->SetTotalRaBlocksMerged(total_blocks_merged);
-
- // Flush the data only if we have a overlapping blocks in the region
- if (!snapuserd_->ReadAheadIOCompleted(overlap_)) {
- SNAP_LOG(ERROR) << "ReadAheadIOCompleted failed...";
- snapuserd_->ReadAheadIOFailed();
- return false;
- }
-
- return true;
-}
-
-bool ReadAheadThread::RunThread() {
- if (!InitializeFds()) {
- return false;
- }
-
- InitializeRAIter();
- InitializeBuffer();
-
- while (!RAIterDone()) {
- if (!ReadAheadIOStart()) {
- return false;
- }
-
- bool status = snapuserd_->WaitForMergeToComplete();
-
- if (status && !snapuserd_->CommitMerge(snapuserd_->GetTotalRaBlocksMerged())) {
- return false;
- }
-
- if (!status) break;
- }
-
- CloseFds();
- SNAP_LOG(INFO) << " ReadAhead thread terminating....";
- return true;
-}
-
-// Initialization
-bool ReadAheadThread::InitializeFds() {
- backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
- if (backing_store_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
- return false;
- }
-
- cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
- if (cow_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
- return false;
- }
-
- return true;
-}
-
-void ReadAheadThread::InitializeRAIter() {
- std::vector<const CowOperation*>& read_ahead_ops = snapuserd_->GetReadAheadOpsVec();
- read_ahead_iter_ = read_ahead_ops.rbegin();
-}
-
-bool ReadAheadThread::RAIterDone() {
- std::vector<const CowOperation*>& read_ahead_ops = snapuserd_->GetReadAheadOpsVec();
- return read_ahead_iter_ == read_ahead_ops.rend();
-}
-
-void ReadAheadThread::RAIterNext() {
- read_ahead_iter_++;
-}
-
-const CowOperation* ReadAheadThread::GetRAOpIter() {
- return *read_ahead_iter_;
-}
-
-void ReadAheadThread::InitializeBuffer() {
- void* mapped_addr = snapuserd_->GetMappedAddr();
- // Map the scratch space region into memory
- metadata_buffer_ =
- static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferMetadataOffset());
- read_ahead_buffer_ = static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferDataOffset());
-}
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp
deleted file mode 100644
index 577b09d..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <arpa/inet.h>
-#include <cutils/sockets.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <android-base/cmsg.h>
-#include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/scopeguard.h>
-#include <fs_mgr/file_wait.h>
-#include <snapuserd/snapuserd_client.h>
-
-#include "snapuserd_server.h"
-
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace std::string_literals;
-
-using android::base::borrowed_fd;
-using android::base::unique_fd;
-
-DaemonOperations SnapuserdServer::Resolveop(std::string& input) {
- if (input == "init") return DaemonOperations::INIT;
- if (input == "start") return DaemonOperations::START;
- if (input == "stop") return DaemonOperations::STOP;
- if (input == "query") return DaemonOperations::QUERY;
- if (input == "delete") return DaemonOperations::DELETE;
- if (input == "detach") return DaemonOperations::DETACH;
- if (input == "supports") return DaemonOperations::SUPPORTS;
-
- return DaemonOperations::INVALID;
-}
-
-SnapuserdServer::~SnapuserdServer() {
- // Close any client sockets that were added via AcceptClient().
- for (size_t i = 1; i < watched_fds_.size(); i++) {
- close(watched_fds_[i].fd);
- }
-}
-
-std::string SnapuserdServer::GetDaemonStatus() {
- std::string msg = "";
-
- if (IsTerminating())
- msg = "passive";
- else
- msg = "active";
-
- return msg;
-}
-
-void SnapuserdServer::Parsemsg(std::string const& msg, const char delim,
- std::vector<std::string>& out) {
- std::stringstream ss(msg);
- std::string s;
-
- while (std::getline(ss, s, delim)) {
- out.push_back(s);
- }
-}
-
-void SnapuserdServer::ShutdownThreads() {
- StopThreads();
- JoinAllThreads();
-}
-
-DmUserHandler::DmUserHandler(std::shared_ptr<Snapuserd> snapuserd)
- : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
-bool SnapuserdServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
- ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
- if (ret < 0) {
- PLOG(ERROR) << "Snapuserd:server: send() failed";
- return false;
- }
-
- if (ret < msg.size()) {
- LOG(ERROR) << "Partial send; expected " << msg.size() << " bytes, sent " << ret;
- return false;
- }
- return true;
-}
-
-bool SnapuserdServer::Recv(android::base::borrowed_fd fd, std::string* data) {
- char msg[MAX_PACKET_SIZE];
- ssize_t rv = TEMP_FAILURE_RETRY(recv(fd.get(), msg, sizeof(msg), 0));
- if (rv < 0) {
- PLOG(ERROR) << "recv failed";
- return false;
- }
- *data = std::string(msg, rv);
- return true;
-}
-
-bool SnapuserdServer::Receivemsg(android::base::borrowed_fd fd, const std::string& str) {
- const char delim = ',';
-
- std::vector<std::string> out;
- Parsemsg(str, delim, out);
- DaemonOperations op = Resolveop(out[0]);
-
- switch (op) {
- case DaemonOperations::INIT: {
- // Message format:
- // init,<misc_name>,<cow_device_path>,<backing_device>
- //
- // Reads the metadata and send the number of sectors
- if (out.size() != 4) {
- LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
- return Sendmsg(fd, "fail");
- }
-
- auto handler = AddHandler(out[1], out[2], out[3]);
- if (!handler) {
- return Sendmsg(fd, "fail");
- }
-
- auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
- return Sendmsg(fd, retval);
- }
- case DaemonOperations::START: {
- // Message format:
- // start,<misc_name>
- //
- // Start the new thread which binds to dm-user misc device
- if (out.size() != 2) {
- LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
- return Sendmsg(fd, "fail");
- }
-
- std::lock_guard<std::mutex> lock(lock_);
- auto iter = FindHandler(&lock, out[1]);
- if (iter == dm_users_.end()) {
- LOG(ERROR) << "Could not find handler: " << out[1];
- return Sendmsg(fd, "fail");
- }
- if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
- LOG(ERROR) << "Tried to re-attach control device: " << out[1];
- return Sendmsg(fd, "fail");
- }
- if (!StartHandler(*iter)) {
- return Sendmsg(fd, "fail");
- }
- return Sendmsg(fd, "success");
- }
- case DaemonOperations::STOP: {
- // Message format: stop
- //
- // Stop all the threads gracefully and then shutdown the
- // main thread
- SetTerminating();
- ShutdownThreads();
- return true;
- }
- case DaemonOperations::QUERY: {
- // Message format: query
- //
- // As part of transition, Second stage daemon will be
- // created before terminating the first stage daemon. Hence,
- // for a brief period client may have to distiguish between
- // first stage daemon and second stage daemon.
- //
- // Second stage daemon is marked as active and hence will
- // be ready to receive control message.
- return Sendmsg(fd, GetDaemonStatus());
- }
- case DaemonOperations::DELETE: {
- // Message format:
- // delete,<misc_name>
- if (out.size() != 2) {
- LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
- return Sendmsg(fd, "fail");
- }
- if (!RemoveAndJoinHandler(out[1])) {
- return Sendmsg(fd, "fail");
- }
- return Sendmsg(fd, "success");
- }
- case DaemonOperations::DETACH: {
- terminating_ = true;
- return true;
- }
- case DaemonOperations::SUPPORTS: {
- if (out.size() != 2) {
- LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
- return Sendmsg(fd, "fail");
- }
- if (out[1] == "second_stage_socket_handoff") {
- return Sendmsg(fd, "success");
- }
- return Sendmsg(fd, "fail");
- }
- default: {
- LOG(ERROR) << "Received unknown message type from client";
- Sendmsg(fd, "fail");
- return false;
- }
- }
-}
-
-void SnapuserdServer::RunThread(std::shared_ptr<DmUserHandler> handler) {
- LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
- handler->snapuserd()->SetSocketPresent(is_socket_present_);
- if (!handler->snapuserd()->Start()) {
- LOG(ERROR) << " Failed to launch all worker threads";
- }
-
- handler->snapuserd()->CloseFds();
- handler->snapuserd()->CheckMergeCompletionStatus();
- handler->snapuserd()->UnmapBufferRegion();
-
- auto misc_name = handler->misc_name();
- LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
- {
- std::lock_guard<std::mutex> lock(lock_);
- auto iter = FindHandler(&lock, handler->misc_name());
- if (iter == dm_users_.end()) {
- // RemoveAndJoinHandler() already removed us from the list, and is
- // now waiting on a join(), so just return. Additionally, release
- // all the resources held by snapuserd object which are shared
- // by worker threads. This should be done when the last reference
- // of "handler" is released; but we will explicitly release here
- // to make sure snapuserd object is freed as it is the biggest
- // consumer of memory in the daemon.
- handler->FreeResources();
- LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
- return;
- }
-
- LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
- if (handler->snapuserd()->IsAttached()) {
- handler->thread().detach();
- }
-
- // Important: free resources within the lock. This ensures that if
- // WaitForDelete() is called, the handler is either in the list, or
- // it's not and its resources are guaranteed to be freed.
- handler->FreeResources();
- }
-}
-
-bool SnapuserdServer::Start(const std::string& socketname) {
- bool start_listening = true;
-
- sockfd_.reset(android_get_control_socket(socketname.c_str()));
- if (sockfd_ < 0) {
- sockfd_.reset(socket_local_server(socketname.c_str(), ANDROID_SOCKET_NAMESPACE_RESERVED,
- SOCK_STREAM));
- if (sockfd_ < 0) {
- PLOG(ERROR) << "Failed to create server socket " << socketname;
- return false;
- }
- start_listening = false;
- }
- return StartWithSocket(start_listening);
-}
-
-bool SnapuserdServer::StartWithSocket(bool start_listening) {
- if (start_listening && listen(sockfd_.get(), 4) < 0) {
- PLOG(ERROR) << "listen socket failed";
- return false;
- }
-
- AddWatchedFd(sockfd_, POLLIN);
- is_socket_present_ = true;
-
- // If started in first-stage init, the property service won't be online.
- if (access("/dev/socket/property_service", F_OK) == 0) {
- if (!android::base::SetProperty("snapuserd.ready", "true")) {
- LOG(ERROR) << "Failed to set snapuserd.ready property";
- return false;
- }
- }
-
- LOG(DEBUG) << "Snapuserd server now accepting connections";
- return true;
-}
-
-bool SnapuserdServer::Run() {
- LOG(INFO) << "Now listening on snapuserd socket";
-
- while (!IsTerminating()) {
- int rv = TEMP_FAILURE_RETRY(poll(watched_fds_.data(), watched_fds_.size(), -1));
- if (rv < 0) {
- PLOG(ERROR) << "poll failed";
- return false;
- }
- if (!rv) {
- continue;
- }
-
- if (watched_fds_[0].revents) {
- AcceptClient();
- }
-
- auto iter = watched_fds_.begin() + 1;
- while (iter != watched_fds_.end()) {
- if (iter->revents && !HandleClient(iter->fd, iter->revents)) {
- close(iter->fd);
- iter = watched_fds_.erase(iter);
- } else {
- iter++;
- }
- }
- }
-
- JoinAllThreads();
- return true;
-}
-
-void SnapuserdServer::JoinAllThreads() {
- // Acquire the thread list within the lock.
- std::vector<std::shared_ptr<DmUserHandler>> dm_users;
- {
- std::lock_guard<std::mutex> guard(lock_);
- dm_users = std::move(dm_users_);
- }
-
- for (auto& client : dm_users) {
- auto& th = client->thread();
-
- if (th.joinable()) th.join();
- }
-}
-
-void SnapuserdServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
- struct pollfd p = {};
- p.fd = fd.get();
- p.events = events;
- watched_fds_.emplace_back(std::move(p));
-}
-
-void SnapuserdServer::AcceptClient() {
- int fd = TEMP_FAILURE_RETRY(accept4(sockfd_.get(), nullptr, nullptr, SOCK_CLOEXEC));
- if (fd < 0) {
- PLOG(ERROR) << "accept4 failed";
- return;
- }
-
- AddWatchedFd(fd, POLLIN);
-}
-
-bool SnapuserdServer::HandleClient(android::base::borrowed_fd fd, int revents) {
- if (revents & POLLHUP) {
- LOG(DEBUG) << "Snapuserd client disconnected";
- return false;
- }
-
- std::string str;
- if (!Recv(fd, &str)) {
- return false;
- }
- if (!Receivemsg(fd, str)) {
- LOG(ERROR) << "Encountered error handling client message, revents: " << revents;
- return false;
- }
- return true;
-}
-
-void SnapuserdServer::Interrupt() {
- // Force close the socket so poll() fails.
- sockfd_ = {};
- SetTerminating();
-}
-
-std::shared_ptr<DmUserHandler> SnapuserdServer::AddHandler(const std::string& misc_name,
- const std::string& cow_device_path,
- const std::string& backing_device) {
- auto snapuserd = std::make_shared<Snapuserd>(misc_name, cow_device_path, backing_device);
- if (!snapuserd->InitCowDevice()) {
- LOG(ERROR) << "Failed to initialize Snapuserd";
- return nullptr;
- }
-
- if (!snapuserd->InitializeWorkers()) {
- LOG(ERROR) << "Failed to initialize workers";
- return nullptr;
- }
-
- auto handler = std::make_shared<DmUserHandler>(snapuserd);
- {
- std::lock_guard<std::mutex> lock(lock_);
- if (FindHandler(&lock, misc_name) != dm_users_.end()) {
- LOG(ERROR) << "Handler already exists: " << misc_name;
- return nullptr;
- }
- dm_users_.push_back(handler);
- }
- return handler;
-}
-
-bool SnapuserdServer::StartHandler(const std::shared_ptr<DmUserHandler>& handler) {
- if (handler->snapuserd()->IsAttached()) {
- LOG(ERROR) << "Handler already attached";
- return false;
- }
-
- handler->snapuserd()->AttachControlDevice();
-
- handler->thread() = std::thread(std::bind(&SnapuserdServer::RunThread, this, handler));
- return true;
-}
-
-auto SnapuserdServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
- const std::string& misc_name) -> HandlerList::iterator {
- CHECK(proof_of_lock);
-
- for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
- if ((*iter)->misc_name() == misc_name) {
- return iter;
- }
- }
- return dm_users_.end();
-}
-
-bool SnapuserdServer::RemoveAndJoinHandler(const std::string& misc_name) {
- std::shared_ptr<DmUserHandler> handler;
- {
- std::lock_guard<std::mutex> lock(lock_);
-
- auto iter = FindHandler(&lock, misc_name);
- if (iter == dm_users_.end()) {
- // Client already deleted.
- return true;
- }
- handler = std::move(*iter);
- dm_users_.erase(iter);
- }
-
- auto& th = handler->thread();
- if (th.joinable()) {
- th.join();
- }
- return true;
-}
-
-bool SnapuserdServer::WaitForSocket() {
- auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
-
- auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
-
- if (!android::fs_mgr::WaitForFile(socket_path, std::chrono::milliseconds::max())) {
- LOG(ERROR)
- << "Failed to wait for proxy socket, second-stage snapuserd will fail to connect";
- return false;
- }
-
- // We must re-initialize property service access, since we launched before
- // second-stage init.
- __system_properties_init();
-
- if (!android::base::WaitForProperty("snapuserd.proxy_ready", "true")) {
- LOG(ERROR)
- << "Failed to wait for proxy property, second-stage snapuserd will fail to connect";
- return false;
- }
-
- unique_fd fd(socket_local_client(kSnapuserdSocketProxy, ANDROID_SOCKET_NAMESPACE_RESERVED,
- SOCK_SEQPACKET));
- if (fd < 0) {
- PLOG(ERROR) << "Failed to connect to socket proxy";
- return false;
- }
-
- char code[1];
- std::vector<unique_fd> fds;
- ssize_t rv = android::base::ReceiveFileDescriptorVector(fd, code, sizeof(code), 1, &fds);
- if (rv < 0) {
- PLOG(ERROR) << "Failed to receive server socket over proxy";
- return false;
- }
- if (fds.empty()) {
- LOG(ERROR) << "Expected at least one file descriptor from proxy";
- return false;
- }
-
- // We don't care if the ACK is received.
- code[0] = 'a';
- if (TEMP_FAILURE_RETRY(send(fd, code, sizeof(code), MSG_NOSIGNAL)) < 0) {
- PLOG(ERROR) << "Failed to send ACK to proxy";
- return false;
- }
-
- sockfd_ = std::move(fds[0]);
- if (!StartWithSocket(true)) {
- return false;
- }
- return Run();
-}
-
-bool SnapuserdServer::RunForSocketHandoff() {
- unique_fd proxy_fd(android_get_control_socket(kSnapuserdSocketProxy));
- if (proxy_fd < 0) {
- PLOG(FATAL) << "Proxy could not get android control socket " << kSnapuserdSocketProxy;
- }
- borrowed_fd server_fd(android_get_control_socket(kSnapuserdSocket));
- if (server_fd < 0) {
- PLOG(FATAL) << "Proxy could not get android control socket " << kSnapuserdSocket;
- }
-
- if (listen(proxy_fd.get(), 4) < 0) {
- PLOG(FATAL) << "Proxy listen socket failed";
- }
-
- if (!android::base::SetProperty("snapuserd.proxy_ready", "true")) {
- LOG(FATAL) << "Proxy failed to set ready property";
- }
-
- unique_fd client_fd(
- TEMP_FAILURE_RETRY(accept4(proxy_fd.get(), nullptr, nullptr, SOCK_CLOEXEC)));
- if (client_fd < 0) {
- PLOG(FATAL) << "Proxy accept failed";
- }
-
- char code[1] = {'a'};
- std::vector<int> fds = {server_fd.get()};
- ssize_t rv = android::base::SendFileDescriptorVector(client_fd, code, sizeof(code), fds);
- if (rv < 0) {
- PLOG(FATAL) << "Proxy could not send file descriptor to snapuserd";
- }
- // Wait for an ACK - results don't matter, we just don't want to risk closing
- // the proxy socket too early.
- if (recv(client_fd, code, sizeof(code), 0) < 0) {
- PLOG(FATAL) << "Proxy could not receive terminating code from snapuserd";
- }
- return true;
-}
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h
deleted file mode 100644
index 3b6ff15..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (C) 2020 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 <poll.h>
-
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <future>
-#include <iostream>
-#include <mutex>
-#include <sstream>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include <android-base/unique_fd.h>
-#include "snapuserd.h"
-
-namespace android {
-namespace snapshot {
-
-static constexpr uint32_t MAX_PACKET_SIZE = 512;
-
-enum class DaemonOperations {
- INIT,
- START,
- QUERY,
- STOP,
- DELETE,
- DETACH,
- SUPPORTS,
- INVALID,
-};
-
-class DmUserHandler {
- public:
- explicit DmUserHandler(std::shared_ptr<Snapuserd> snapuserd);
-
- void FreeResources() {
- // Each worker thread holds a reference to snapuserd.
- // Clear them so that all the resources
- // held by snapuserd is released
- if (snapuserd_) {
- snapuserd_->FreeResources();
- snapuserd_ = nullptr;
- }
- }
- const std::shared_ptr<Snapuserd>& snapuserd() const { return snapuserd_; }
- std::thread& thread() { return thread_; }
-
- const std::string& misc_name() const { return misc_name_; }
-
- private:
- std::thread thread_;
- std::shared_ptr<Snapuserd> snapuserd_;
- std::string misc_name_;
-};
-
-class Stoppable {
- std::promise<void> exitSignal_;
- std::future<void> futureObj_;
-
- public:
- Stoppable() : futureObj_(exitSignal_.get_future()) {}
-
- virtual ~Stoppable() {}
-
- bool StopRequested() {
- // checks if value in future object is available
- if (futureObj_.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout) {
- return false;
- }
- return true;
- }
- // Request the thread to stop by setting value in promise object
- void StopThreads() { exitSignal_.set_value(); }
-};
-
-class SnapuserdServer : public Stoppable {
- private:
- android::base::unique_fd sockfd_;
- bool terminating_;
- volatile bool received_socket_signal_ = false;
- std::vector<struct pollfd> watched_fds_;
- bool is_socket_present_ = false;
-
- std::mutex lock_;
-
- using HandlerList = std::vector<std::shared_ptr<DmUserHandler>>;
- HandlerList dm_users_;
-
- void AddWatchedFd(android::base::borrowed_fd fd, int events);
- void AcceptClient();
- bool HandleClient(android::base::borrowed_fd fd, int revents);
- bool Recv(android::base::borrowed_fd fd, std::string* data);
- bool Sendmsg(android::base::borrowed_fd fd, const std::string& msg);
- bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
-
- void ShutdownThreads();
- bool RemoveAndJoinHandler(const std::string& control_device);
- DaemonOperations Resolveop(std::string& input);
- std::string GetDaemonStatus();
- void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
-
- bool IsTerminating() { return terminating_; }
-
- void RunThread(std::shared_ptr<DmUserHandler> handler);
- void JoinAllThreads();
- bool StartWithSocket(bool start_listening);
-
- // Find a DmUserHandler within a lock.
- HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
- const std::string& misc_name);
-
- public:
- SnapuserdServer() { terminating_ = false; }
- ~SnapuserdServer();
-
- bool Start(const std::string& socketname);
- bool Run();
- void Interrupt();
- bool RunForSocketHandoff();
- bool WaitForSocket();
-
- std::shared_ptr<DmUserHandler> AddHandler(const std::string& misc_name,
- const std::string& cow_device_path,
- const std::string& backing_device);
- bool StartHandler(const std::shared_ptr<DmUserHandler>& handler);
-
- void SetTerminating() { terminating_ = true; }
- void ReceivedSocketSignal() { received_socket_signal_ = true; }
-};
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
deleted file mode 100644
index 1f5d568..0000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ /dev/null
@@ -1,869 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-WorkerThread::WorkerThread(const std::string& cow_device, const std::string& backing_device,
- const std::string& control_device, const std::string& misc_name,
- std::shared_ptr<Snapuserd> snapuserd) {
- cow_device_ = cow_device;
- backing_store_device_ = backing_device;
- control_device_ = control_device;
- misc_name_ = misc_name;
- snapuserd_ = snapuserd;
- exceptions_per_area_ = (CHUNK_SIZE << SECTOR_SHIFT) / sizeof(struct disk_exception);
-}
-
-bool WorkerThread::InitializeFds() {
- backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
- if (backing_store_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
- return false;
- }
-
- cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
- if (cow_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
- return false;
- }
-
- ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
- if (ctrl_fd_ < 0) {
- SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
- return false;
- }
-
- return true;
-}
-
-bool WorkerThread::InitReader() {
- reader_ = snapuserd_->CloneReaderForWorker();
-
- if (!reader_->InitForMerge(std::move(cow_fd_))) {
- return false;
- }
- return true;
-}
-
-// Construct kernel COW header in memory
-// This header will be in sector 0. The IO
-// request will always be 4k. After constructing
-// the header, zero out the remaining block.
-void WorkerThread::ConstructKernelCowHeader() {
- void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-
- memset(buffer, 0, BLOCK_SZ);
-
- struct disk_header* dh = reinterpret_cast<struct disk_header*>(buffer);
-
- dh->magic = SNAP_MAGIC;
- dh->valid = SNAPSHOT_VALID;
- dh->version = SNAPSHOT_DISK_VERSION;
- dh->chunk_size = CHUNK_SIZE;
-}
-
-// Start the replace operation. This will read the
-// internal COW format and if the block is compressed,
-// it will be de-compressed.
-bool WorkerThread::ProcessReplaceOp(const CowOperation* cow_op) {
- void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
- if (!buffer) {
- SNAP_LOG(ERROR) << "No space in buffer sink";
- return false;
- }
- ssize_t rv = reader_->ReadData(cow_op, buffer, BLOCK_SZ);
- if (rv != BLOCK_SZ) {
- SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block
- << ", return = " << rv << ", COW operation = " << *cow_op;
- return false;
- }
- return true;
-}
-
-bool WorkerThread::ReadFromBaseDevice(const CowOperation* cow_op) {
- void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
- return false;
- }
- uint64_t offset;
- if (!reader_->GetSourceOffset(cow_op, &offset)) {
- SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get source offset";
- return false;
- }
- SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
- << " Source: " << offset;
- if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
- SNAP_PLOG(ERROR) << "Copy op failed. Read from backing store: " << backing_store_device_
- << "at block :" << offset / BLOCK_SZ << " offset:" << offset % BLOCK_SZ;
- return false;
- }
-
- return true;
-}
-
-bool WorkerThread::GetReadAheadPopulatedBuffer(const CowOperation* cow_op) {
- void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "GetReadAheadPopulatedBuffer: Failed to get payload buffer";
- return false;
- }
-
- if (!snapuserd_->GetReadAheadPopulatedBuffer(cow_op->new_block, buffer)) {
- return false;
- }
-
- return true;
-}
-
-// Start the copy operation. This will read the backing
-// block device which is represented by cow_op->source.
-bool WorkerThread::ProcessCopyOp(const CowOperation* cow_op) {
- if (!GetReadAheadPopulatedBuffer(cow_op)) {
- SNAP_LOG(DEBUG) << " GetReadAheadPopulatedBuffer failed..."
- << " new_block: " << cow_op->new_block;
- if (!ReadFromBaseDevice(cow_op)) {
- return false;
- }
- }
-
- return true;
-}
-
-bool WorkerThread::ProcessZeroOp() {
- // Zero out the entire block
- void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "ProcessZeroOp: Failed to get payload buffer";
- return false;
- }
-
- memset(buffer, 0, BLOCK_SZ);
- return true;
-}
-
-bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
- if (cow_op == nullptr) {
- SNAP_LOG(ERROR) << "ProcessCowOp: Invalid cow_op";
- return false;
- }
-
- switch (cow_op->type()) {
- case kCowReplaceOp: {
- return ProcessReplaceOp(cow_op);
- }
-
- case kCowZeroOp: {
- return ProcessZeroOp();
- }
-
- case kCowCopyOp: {
- return ProcessCopyOp(cow_op);
- }
-
- default: {
- SNAP_LOG(ERROR) << "Unsupported operation-type found: "
- << static_cast<uint8_t>(cow_op->type());
- }
- }
- return false;
-}
-
-int WorkerThread::ReadUnalignedSector(
- sector_t sector, size_t size,
- std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it) {
- size_t skip_sector_size = 0;
-
- SNAP_LOG(DEBUG) << "ReadUnalignedSector: sector " << sector << " size: " << size
- << " Aligned sector: " << it->first;
-
- if (!ProcessCowOp(it->second)) {
- SNAP_LOG(ERROR) << "ReadUnalignedSector: " << sector << " failed of size: " << size
- << " Aligned sector: " << it->first;
- return -1;
- }
-
- int num_sectors_skip = sector - it->first;
-
- if (num_sectors_skip > 0) {
- skip_sector_size = num_sectors_skip << SECTOR_SHIFT;
- char* buffer = reinterpret_cast<char*>(bufsink_.GetBufPtr());
- struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));
-
- if (skip_sector_size == BLOCK_SZ) {
- SNAP_LOG(ERROR) << "Invalid un-aligned IO request at sector: " << sector
- << " Base-sector: " << it->first;
- return -1;
- }
-
- memmove(msg->payload.buf, (char*)msg->payload.buf + skip_sector_size,
- (BLOCK_SZ - skip_sector_size));
- }
-
- bufsink_.ResetBufferOffset();
- return std::min(size, (BLOCK_SZ - skip_sector_size));
-}
-
-/*
- * Read the data for a given COW Operation.
- *
- * Kernel can issue IO at a sector granularity.
- * Hence, an IO may end up with reading partial
- * data from a COW operation or we may also
- * end up with interspersed request between
- * two COW operations.
- *
- */
-int WorkerThread::ReadData(sector_t sector, size_t size) {
- std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
- std::vector<std::pair<sector_t, const CowOperation*>>::iterator it;
- /*
- * chunk_map stores COW operation at 4k granularity.
- * If the requested IO with the sector falls on the 4k
- * boundary, then we can read the COW op directly without
- * any issue.
- *
- * However, if the requested sector is not 4K aligned,
- * then we will have the find the nearest COW operation
- * and chop the 4K block to fetch the requested sector.
- */
- it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(), std::make_pair(sector, nullptr),
- Snapuserd::compare);
-
- bool read_end_of_device = false;
- if (it == chunk_vec.end()) {
- // |-------|-------|-------|
- // 0 1 2 3
- //
- // Block 0 - op 1
- // Block 1 - op 2
- // Block 2 - op 3
- //
- // chunk_vec will have block 0, 1, 2 which maps to relavant COW ops.
- //
- // Each block is 4k bytes. Thus, the last block will span 8 sectors
- // ranging till block 3 (However, block 3 won't be in chunk_vec as
- // it doesn't have any mapping to COW ops. Now, if we get an I/O request for a sector
- // spanning between block 2 and block 3, we need to step back
- // and get hold of the last element.
- //
- // Additionally, dm-snapshot makes sure that I/O request beyond block 3
- // will not be routed to the daemon. Hence, it is safe to assume that
- // if a sector is not available in the chunk_vec, the I/O falls in the
- // end of region.
- it = std::prev(chunk_vec.end());
- read_end_of_device = true;
- }
-
- // We didn't find the required sector; hence find the previous sector
- // as lower_bound will gives us the value greater than
- // the requested sector
- if (it->first != sector) {
- if (it != chunk_vec.begin() && !read_end_of_device) {
- --it;
- }
-
- /*
- * If the IO is spanned between two COW operations,
- * split the IO into two parts:
- *
- * 1: Read the first part from the single COW op
- * 2: Read the second part from the next COW op.
- *
- * Ex: Let's say we have a 1024 Bytes IO request.
- *
- * 0 COW OP-1 4096 COW OP-2 8192
- * |******************|*******************|
- * |*****|*****|
- * 3584 4608
- * <- 1024B - >
- *
- * We have two COW operations which are 4k blocks.
- * The IO is requested for 1024 Bytes which are spanned
- * between two COW operations. We will split this IO
- * into two parts:
- *
- * 1: IO of size 512B from offset 3584 bytes (COW OP-1)
- * 2: IO of size 512B from offset 4096 bytes (COW OP-2)
- */
- return ReadUnalignedSector(sector, size, it);
- }
-
- int num_ops = DIV_ROUND_UP(size, BLOCK_SZ);
- sector_t read_sector = sector;
- while (num_ops) {
- // We have to make sure that the reads are
- // sequential; there shouldn't be a data
- // request merged with a metadata IO.
- if (it->first != read_sector) {
- SNAP_LOG(ERROR) << "Invalid IO request: read_sector: " << read_sector
- << " cow-op sector: " << it->first;
- return -1;
- } else if (!ProcessCowOp(it->second)) {
- return -1;
- }
- num_ops -= 1;
- read_sector += (BLOCK_SZ >> SECTOR_SHIFT);
-
- it++;
-
- if (it == chunk_vec.end() && num_ops) {
- SNAP_LOG(ERROR) << "Invalid IO request at sector " << sector
- << " COW ops completed; pending read-request: " << num_ops;
- return -1;
- }
- // Update the buffer offset
- bufsink_.UpdateBufferOffset(BLOCK_SZ);
- }
-
- // Reset the buffer offset
- bufsink_.ResetBufferOffset();
- return size;
-}
-
-/*
- * dm-snap does prefetch reads while reading disk-exceptions.
- * By default, prefetch value is set to 12; this means that
- * dm-snap will issue 12 areas wherein each area is a 4k page
- * of disk-exceptions.
- *
- * If during prefetch, if the chunk-id seen is beyond the
- * actual number of metadata page, fill the buffer with zero.
- * When dm-snap starts parsing the buffer, it will stop
- * reading metadata page once the buffer content is zero.
- */
-bool WorkerThread::ZerofillDiskExceptions(size_t read_size) {
- size_t size = exceptions_per_area_ * sizeof(struct disk_exception);
-
- if (read_size > size) {
- return false;
- }
-
- void* buffer = bufsink_.GetPayloadBuffer(size);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "ZerofillDiskExceptions: Failed to get payload buffer";
- return false;
- }
-
- memset(buffer, 0, size);
- return true;
-}
-
-/*
- * A disk exception is a simple mapping of old_chunk to new_chunk.
- * When dm-snapshot device is created, kernel requests these mapping.
- *
- * Each disk exception is of size 16 bytes. Thus a single 4k page can
- * have:
- *
- * exceptions_per_area_ = 4096/16 = 256. This entire 4k page
- * is considered a metadata page and it is represented by chunk ID.
- *
- * Convert the chunk ID to index into the vector which gives us
- * the metadata page.
- */
-bool WorkerThread::ReadDiskExceptions(chunk_t chunk, size_t read_size) {
- uint32_t stride = exceptions_per_area_ + 1;
- size_t size;
- const std::vector<std::unique_ptr<uint8_t[]>>& vec = snapuserd_->GetMetadataVec();
-
- // ChunkID to vector index
- lldiv_t divresult = lldiv(chunk, stride);
-
- if (divresult.quot < vec.size()) {
- size = exceptions_per_area_ * sizeof(struct disk_exception);
-
- if (read_size != size) {
- SNAP_LOG(ERROR) << "ReadDiskExceptions: read_size: " << read_size
- << " does not match with size: " << size;
- return false;
- }
-
- void* buffer = bufsink_.GetPayloadBuffer(size);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "ReadDiskExceptions: Failed to get payload buffer of size: " << size;
- return false;
- }
-
- memcpy(buffer, vec[divresult.quot].get(), size);
- } else {
- return ZerofillDiskExceptions(read_size);
- }
-
- return true;
-}
-
-loff_t WorkerThread::GetMergeStartOffset(void* merged_buffer, void* unmerged_buffer,
- int* unmerged_exceptions) {
- loff_t offset = 0;
- *unmerged_exceptions = 0;
-
- while (*unmerged_exceptions <= exceptions_per_area_) {
- struct disk_exception* merged_de =
- reinterpret_cast<struct disk_exception*>((char*)merged_buffer + offset);
- struct disk_exception* cow_de =
- reinterpret_cast<struct disk_exception*>((char*)unmerged_buffer + offset);
-
- // Unmerged op by the kernel
- if (merged_de->old_chunk != 0 || merged_de->new_chunk != 0) {
- if (!(merged_de->old_chunk == cow_de->old_chunk)) {
- SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->old_chunk: "
- << merged_de->old_chunk
- << "cow_de->old_chunk: " << cow_de->old_chunk;
- return -1;
- }
-
- if (!(merged_de->new_chunk == cow_de->new_chunk)) {
- SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->new_chunk: "
- << merged_de->new_chunk
- << "cow_de->new_chunk: " << cow_de->new_chunk;
- return -1;
- }
-
- offset += sizeof(struct disk_exception);
- *unmerged_exceptions += 1;
- continue;
- }
-
- break;
- }
-
- SNAP_LOG(DEBUG) << "Unmerged_Exceptions: " << *unmerged_exceptions << " Offset: " << offset;
- return offset;
-}
-
-int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffer, loff_t offset,
- int unmerged_exceptions, bool* ordered_op, bool* commit) {
- int merged_ops_cur_iter = 0;
- std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
- *ordered_op = false;
- std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-
- // Find the operations which are merged in this cycle.
- while ((unmerged_exceptions + merged_ops_cur_iter) < exceptions_per_area_) {
- struct disk_exception* merged_de =
- reinterpret_cast<struct disk_exception*>((char*)merged_buffer + offset);
- struct disk_exception* cow_de =
- reinterpret_cast<struct disk_exception*>((char*)unmerged_buffer + offset);
-
- if (!(merged_de->new_chunk == 0)) {
- SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid new-chunk: " << merged_de->new_chunk;
- return -1;
- }
-
- if (!(merged_de->old_chunk == 0)) {
- SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid old-chunk: " << merged_de->old_chunk;
- return -1;
- }
-
- if (cow_de->new_chunk != 0) {
- merged_ops_cur_iter += 1;
- offset += sizeof(struct disk_exception);
- auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
- std::make_pair(ChunkToSector(cow_de->new_chunk), nullptr),
- Snapuserd::compare);
-
- if (!(it != chunk_vec.end())) {
- SNAP_LOG(ERROR) << "Sector not found: " << ChunkToSector(cow_de->new_chunk);
- return -1;
- }
-
- if (!(it->first == ChunkToSector(cow_de->new_chunk))) {
- SNAP_LOG(ERROR) << "Invalid sector: " << ChunkToSector(cow_de->new_chunk);
- return -1;
- }
- const CowOperation* cow_op = it->second;
-
- if (snapuserd_->IsReadAheadFeaturePresent() && IsOrderedOp(*cow_op)) {
- *ordered_op = true;
- // Every single ordered operation has to come from read-ahead
- // cache.
- if (read_ahead_buffer_map.find(cow_op->new_block) == read_ahead_buffer_map.end()) {
- SNAP_LOG(ERROR)
- << " Block: " << cow_op->new_block << " not found in read-ahead cache"
- << " Op: " << *cow_op;
- return -1;
- }
- // If this is a final block merged in the read-ahead buffer
- // region, notify the read-ahead thread to make forward
- // progress
- if (cow_op->new_block == snapuserd_->GetFinalBlockMerged()) {
- *commit = true;
- }
- }
-
- // zero out to indicate that operation is merged.
- cow_de->old_chunk = 0;
- cow_de->new_chunk = 0;
- } else if (cow_de->old_chunk == 0) {
- // Already merged op in previous iteration or
- // This could also represent a partially filled area.
- //
- // If the op was merged in previous cycle, we don't have
- // to count them.
- break;
- } else {
- SNAP_LOG(ERROR) << "Error in merge operation. Found invalid metadata: "
- << " merged_de-old-chunk: " << merged_de->old_chunk
- << " merged_de-new-chunk: " << merged_de->new_chunk
- << " cow_de-old-chunk: " << cow_de->old_chunk
- << " cow_de-new-chunk: " << cow_de->new_chunk
- << " unmerged_exceptions: " << unmerged_exceptions
- << " merged_ops_cur_iter: " << merged_ops_cur_iter
- << " offset: " << offset;
- return -1;
- }
- }
- return merged_ops_cur_iter;
-}
-
-bool WorkerThread::ProcessMergeComplete(chunk_t chunk, void* buffer) {
- uint32_t stride = exceptions_per_area_ + 1;
- const std::vector<std::unique_ptr<uint8_t[]>>& vec = snapuserd_->GetMetadataVec();
- bool ordered_op = false;
- bool commit = false;
-
- // ChunkID to vector index
- lldiv_t divresult = lldiv(chunk, stride);
-
- if (!(divresult.quot < vec.size())) {
- SNAP_LOG(ERROR) << "ProcessMergeComplete: Invalid chunk: " << chunk
- << " Metadata-Index: " << divresult.quot << " Area-size: " << vec.size();
- return false;
- }
-
- SNAP_LOG(DEBUG) << "ProcessMergeComplete: chunk: " << chunk
- << " Metadata-Index: " << divresult.quot;
-
- int unmerged_exceptions = 0;
- loff_t offset = GetMergeStartOffset(buffer, vec[divresult.quot].get(), &unmerged_exceptions);
-
- if (offset < 0) {
- SNAP_LOG(ERROR) << "GetMergeStartOffset failed: unmerged_exceptions: "
- << unmerged_exceptions;
- return false;
- }
-
- int merged_ops_cur_iter = GetNumberOfMergedOps(buffer, vec[divresult.quot].get(), offset,
- unmerged_exceptions, &ordered_op, &commit);
-
- // There should be at least one operation merged in this cycle
- if (!(merged_ops_cur_iter > 0)) {
- SNAP_LOG(ERROR) << "Merge operation failed: " << merged_ops_cur_iter;
- return false;
- }
-
- if (ordered_op) {
- if (commit) {
- // Push the flushing logic to read-ahead thread so that merge thread
- // can make forward progress. Sync will happen in the background
- snapuserd_->StartReadAhead();
- }
- } else {
- // Non-copy ops and all ops in older COW format
- if (!snapuserd_->CommitMerge(merged_ops_cur_iter)) {
- SNAP_LOG(ERROR) << "CommitMerge failed...";
- return false;
- }
- }
-
- SNAP_LOG(DEBUG) << "Merge success: " << merged_ops_cur_iter << "chunk: " << chunk;
- return true;
-}
-
-// Read Header from dm-user misc device. This gives
-// us the sector number for which IO is issued by dm-snapshot device
-bool WorkerThread::ReadDmUserHeader() {
- if (!android::base::ReadFully(ctrl_fd_, bufsink_.GetBufPtr(), sizeof(struct dm_user_header))) {
- if (errno != ENOTBLK) {
- SNAP_PLOG(ERROR) << "Control-read failed";
- }
-
- return false;
- }
-
- return true;
-}
-
-// Send the payload/data back to dm-user misc device.
-bool WorkerThread::WriteDmUserPayload(size_t size, bool header_response) {
- size_t payload_size = size;
- void* buf = bufsink_.GetPayloadBufPtr();
- if (header_response) {
- payload_size += sizeof(struct dm_user_header);
- buf = bufsink_.GetBufPtr();
- }
-
- if (!android::base::WriteFully(ctrl_fd_, buf, payload_size)) {
- SNAP_PLOG(ERROR) << "Write to dm-user failed size: " << payload_size;
- return false;
- }
-
- return true;
-}
-
-bool WorkerThread::ReadDmUserPayload(void* buffer, size_t size) {
- if (!android::base::ReadFully(ctrl_fd_, buffer, size)) {
- SNAP_PLOG(ERROR) << "ReadDmUserPayload failed size: " << size;
- return false;
- }
-
- return true;
-}
-
-bool WorkerThread::DmuserWriteRequest() {
- struct dm_user_header* header = bufsink_.GetHeaderPtr();
-
- // device mapper has the capability to allow
- // targets to flush the cache when writes are completed. This
- // is controlled by each target by a flag "flush_supported".
- // This flag is set by dm-user. When flush is supported,
- // a number of zero-length bio's will be submitted to
- // the target for the purpose of flushing cache. It is the
- // responsibility of the target driver - which is dm-user in this
- // case, to remap these bio's to the underlying device. Since,
- // there is no underlying device for dm-user, this zero length
- // bio's gets routed to daemon.
- //
- // Flush operations are generated post merge by dm-snap by having
- // REQ_PREFLUSH flag set. Snapuser daemon doesn't have anything
- // to flush per se; hence, just respond back with a success message.
- if (header->sector == 0) {
- if (!(header->len == 0)) {
- SNAP_LOG(ERROR) << "Invalid header length received from sector 0: " << header->len;
- header->type = DM_USER_RESP_ERROR;
- } else {
- header->type = DM_USER_RESP_SUCCESS;
- }
-
- if (!WriteDmUserPayload(0, true)) {
- return false;
- }
- return true;
- }
-
- std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
- size_t remaining_size = header->len;
- size_t read_size = std::min(PAYLOAD_SIZE, remaining_size);
-
- chunk_t chunk = SectorToChunk(header->sector);
- auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
- std::make_pair(header->sector, nullptr), Snapuserd::compare);
-
- bool not_found = (it == chunk_vec.end() || it->first != header->sector);
-
- if (not_found) {
- void* buffer = bufsink_.GetPayloadBuffer(read_size);
- if (buffer == nullptr) {
- SNAP_LOG(ERROR) << "DmuserWriteRequest: Failed to get payload buffer of size: "
- << read_size;
- header->type = DM_USER_RESP_ERROR;
- } else {
- header->type = DM_USER_RESP_SUCCESS;
-
- if (!ReadDmUserPayload(buffer, read_size)) {
- SNAP_LOG(ERROR) << "ReadDmUserPayload failed for chunk id: " << chunk
- << "Sector: " << header->sector;
- header->type = DM_USER_RESP_ERROR;
- }
-
- if (header->type == DM_USER_RESP_SUCCESS && !ProcessMergeComplete(chunk, buffer)) {
- SNAP_LOG(ERROR) << "ProcessMergeComplete failed for chunk id: " << chunk
- << "Sector: " << header->sector;
- header->type = DM_USER_RESP_ERROR;
- }
- }
- } else {
- SNAP_LOG(ERROR) << "DmuserWriteRequest: Invalid sector received: header->sector";
- header->type = DM_USER_RESP_ERROR;
- }
-
- if (!WriteDmUserPayload(0, true)) {
- return false;
- }
-
- return true;
-}
-
-bool WorkerThread::DmuserReadRequest() {
- struct dm_user_header* header = bufsink_.GetHeaderPtr();
- size_t remaining_size = header->len;
- loff_t offset = 0;
- sector_t sector = header->sector;
- std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
- bool header_response = true;
- do {
- size_t read_size = std::min(PAYLOAD_SIZE, remaining_size);
-
- int ret = read_size;
- header->type = DM_USER_RESP_SUCCESS;
- chunk_t chunk = SectorToChunk(header->sector);
-
- // Request to sector 0 is always for kernel
- // representation of COW header. This IO should be only
- // once during dm-snapshot device creation. We should
- // never see multiple IO requests. Additionally this IO
- // will always be a single 4k.
- if (header->sector == 0) {
- if (read_size == BLOCK_SZ) {
- ConstructKernelCowHeader();
- SNAP_LOG(DEBUG) << "Kernel header constructed";
- } else {
- SNAP_LOG(ERROR) << "Invalid read_size: " << read_size << " for sector 0";
- header->type = DM_USER_RESP_ERROR;
- }
- } else {
- auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
- std::make_pair(header->sector, nullptr), Snapuserd::compare);
- bool not_found = (it == chunk_vec.end() || it->first != header->sector);
- if (!offset && (read_size == BLOCK_SZ) && not_found) {
- if (!ReadDiskExceptions(chunk, read_size)) {
- SNAP_LOG(ERROR) << "ReadDiskExceptions failed for chunk id: " << chunk
- << "Sector: " << header->sector;
- header->type = DM_USER_RESP_ERROR;
- } else {
- SNAP_LOG(DEBUG) << "ReadDiskExceptions success for chunk id: " << chunk
- << "Sector: " << header->sector;
- }
- } else {
- chunk_t num_sectors_read = (offset >> SECTOR_SHIFT);
-
- ret = ReadData(sector + num_sectors_read, read_size);
- if (ret < 0) {
- SNAP_LOG(ERROR) << "ReadData failed for chunk id: " << chunk
- << " Sector: " << (sector + num_sectors_read)
- << " size: " << read_size << " header-len: " << header->len;
- header->type = DM_USER_RESP_ERROR;
- } else {
- SNAP_LOG(DEBUG) << "ReadData success for chunk id: " << chunk
- << "Sector: " << header->sector;
- }
- }
- }
-
- // Just return the header if it is an error
- if (header->type == DM_USER_RESP_ERROR) {
- SNAP_LOG(ERROR) << "IO read request failed...";
- ret = 0;
- }
-
- if (!header_response) {
- CHECK(header->type == DM_USER_RESP_SUCCESS)
- << " failed for sector: " << sector << " header->len: " << header->len
- << " remaining_size: " << remaining_size;
- }
-
- // Daemon will not be terminated if there is any error. We will
- // just send the error back to dm-user.
- if (!WriteDmUserPayload(ret, header_response)) {
- return false;
- }
-
- if (header->type == DM_USER_RESP_ERROR) {
- break;
- }
-
- remaining_size -= ret;
- offset += ret;
- header_response = false;
- } while (remaining_size > 0);
-
- return true;
-}
-
-void WorkerThread::InitializeBufsink() {
- // Allocate the buffer which is used to communicate between
- // daemon and dm-user. The buffer comprises of header and a fixed payload.
- // If the dm-user requests a big IO, the IO will be broken into chunks
- // of PAYLOAD_SIZE.
- size_t buf_size = sizeof(struct dm_user_header) + PAYLOAD_SIZE;
- bufsink_.Initialize(buf_size);
-}
-
-bool WorkerThread::RunThread() {
- InitializeBufsink();
-
- if (!InitializeFds()) {
- return false;
- }
-
- if (!InitReader()) {
- return false;
- }
-
- // Start serving IO
- while (true) {
- if (!ProcessIORequest()) {
- break;
- }
- }
-
- CloseFds();
- reader_->CloseCowFd();
-
- return true;
-}
-
-bool WorkerThread::ProcessIORequest() {
- struct dm_user_header* header = bufsink_.GetHeaderPtr();
-
- if (!ReadDmUserHeader()) {
- return false;
- }
-
- SNAP_LOG(DEBUG) << "Daemon: msg->seq: " << std::dec << header->seq;
- SNAP_LOG(DEBUG) << "Daemon: msg->len: " << std::dec << header->len;
- SNAP_LOG(DEBUG) << "Daemon: msg->sector: " << std::dec << header->sector;
- SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
- SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
-
- switch (header->type) {
- case DM_USER_REQ_MAP_READ: {
- if (!DmuserReadRequest()) {
- return false;
- }
- break;
- }
-
- case DM_USER_REQ_MAP_WRITE: {
- if (!DmuserWriteRequest()) {
- return false;
- }
- break;
- }
- }
-
- return true;
-}
-
-} // namespace snapshot
-} // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index 36dad33..0ebe543 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -38,20 +38,20 @@
const std::string vendor_release =
android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
- // No user-space snapshots if vendor partition is on Android 12
+ // If the vendor is on Android S, install process will forcefully take the
+ // userspace snapshots path.
+ //
+ // We will not reach here post OTA reboot as the binary will be from vendor
+ // ramdisk which is on Android S.
if (vendor_release.find("12") != std::string::npos) {
- LOG(INFO) << "Userspace snapshots disabled as vendor partition is on Android: "
+ LOG(INFO) << "Userspace snapshots enabled as vendor partition is on Android: "
<< vendor_release;
- return false;
+ return true;
}
return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
}
-bool Daemon::IsDmSnapshotTestingEnabled() {
- return android::base::GetBoolProperty("snapuserd.test.dm.snapshots", false);
-}
-
bool Daemon::StartDaemon(int argc, char** argv) {
int arg_start = gflags::ParseCommandLineFlags(&argc, &argv, true);
@@ -65,16 +65,16 @@
// stage init and hence use the command line flags to get the information.
bool user_snapshots = FLAGS_user_snapshot;
if (!user_snapshots) {
- user_snapshots = (!IsDmSnapshotTestingEnabled() && IsUserspaceSnapshotsEnabled());
+ user_snapshots = IsUserspaceSnapshotsEnabled();
}
if (user_snapshots) {
LOG(INFO) << "Starting daemon for user-space snapshots.....";
return StartServerForUserspaceSnapshots(arg_start, argc, argv);
} else {
- LOG(INFO) << "Starting daemon for dm-snapshots.....";
- return StartServerForDmSnapshot(arg_start, argc, argv);
+ LOG(ERROR) << "Userspace snapshots not enabled. No support for legacy snapshots";
}
+ return false;
}
bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** argv) {
@@ -130,48 +130,6 @@
return user_server_.WaitForSocket();
}
-bool Daemon::StartServerForDmSnapshot(int arg_start, int argc, char** argv) {
- sigfillset(&signal_mask_);
- sigdelset(&signal_mask_, SIGINT);
- sigdelset(&signal_mask_, SIGTERM);
- sigdelset(&signal_mask_, SIGUSR1);
-
- // Masking signals here ensure that after this point, we won't handle INT/TERM
- // until after we call into ppoll()
- signal(SIGINT, Daemon::SignalHandler);
- signal(SIGTERM, Daemon::SignalHandler);
- signal(SIGPIPE, Daemon::SignalHandler);
- signal(SIGUSR1, Daemon::SignalHandler);
-
- MaskAllSignalsExceptIntAndTerm();
-
- if (FLAGS_socket_handoff) {
- return server_.RunForSocketHandoff();
- }
- if (!FLAGS_no_socket) {
- if (!server_.Start(FLAGS_socket)) {
- return false;
- }
- return server_.Run();
- }
-
- for (int i = arg_start; i < argc; i++) {
- auto parts = android::base::Split(argv[i], ",");
- if (parts.size() != 3) {
- LOG(ERROR) << "Malformed message, expected three sub-arguments.";
- return false;
- }
- auto handler = server_.AddHandler(parts[0], parts[1], parts[2]);
- if (!handler || !server_.StartHandler(handler)) {
- return false;
- }
- }
-
- // Skip the accept() call to avoid spurious log spam. The server will still
- // run until all handlers have completed.
- return server_.WaitForSocket();
-}
-
void Daemon::MaskAllSignalsExceptIntAndTerm() {
sigset_t signal_mask;
sigfillset(&signal_mask);
@@ -198,16 +156,12 @@
// and verify it through a temp variable.
if (user_server_.IsServerRunning()) {
user_server_.Interrupt();
- } else {
- server_.Interrupt();
}
}
void Daemon::ReceivedSocketSignal() {
if (user_server_.IsServerRunning()) {
user_server_.ReceivedSocketSignal();
- } else {
- server_.ReceivedSocketSignal();
}
}
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
index cf3b917..303e394 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
@@ -19,7 +19,6 @@
#include <string>
#include <vector>
-#include "dm-snapshot-merge/snapuserd_server.h"
#include "user-space-merge/snapuserd_server.h"
namespace android {
@@ -36,12 +35,10 @@
return instance;
}
- bool StartServerForDmSnapshot(int arg_start, int argc, char** argv);
bool StartServerForUserspaceSnapshots(int arg_start, int argc, char** argv);
void Interrupt();
void ReceivedSocketSignal();
bool IsUserspaceSnapshotsEnabled();
- bool IsDmSnapshotTestingEnabled();
bool StartDaemon(int argc, char** argv);
private:
@@ -51,7 +48,6 @@
Daemon(Daemon const&) = delete;
void operator=(Daemon const&) = delete;
- SnapuserdServer server_;
UserSnapshotServer user_server_;
void MaskAllSignalsExceptIntAndTerm();
void MaskAllSignals();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 76b44b4..56f7b59 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -126,7 +126,8 @@
}
std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
- cow_system_ = std::make_unique<TemporaryFile>();
+ std::string path = android::base::GetExecutableDirectory();
+ cow_system_ = std::make_unique<TemporaryFile>(path);
CowOptions options;
options.compression = "gz";
@@ -134,7 +135,7 @@
unique_fd fd(cow_system_->fd);
cow_system_->fd = -1;
- return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+ return CreateCowWriter(2, options, std::move(fd));
}
std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {
@@ -147,7 +148,8 @@
options.batch_write = true;
options.compression_factor = params.block_size;
- cow_system_ = std::make_unique<TemporaryFile>();
+ std::string path = android::base::GetExecutableDirectory();
+ cow_system_ = std::make_unique<TemporaryFile>(path);
unique_fd fd(cow_system_->fd);
cow_system_->fd = -1;
@@ -989,6 +991,7 @@
void SnapuserdVariableBlockSizeTest::CreateV3CowDeviceForVariableBlockSize() {
auto writer = CreateV3Cow();
+ ASSERT_NE(writer, nullptr);
size_t total_data_to_write = size_;
size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;
@@ -1337,6 +1340,7 @@
void HandlerTestV3::SetUpV3Cow() {
auto writer = CreateV3Cow();
+ ASSERT_NE(writer, nullptr);
size_t total_data_to_write = size_;
size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;
diff --git a/fs_mgr/libsnapshot/utility.cpp b/fs_mgr/libsnapshot/utility.cpp
index 1ffa89c..fe2d95c 100644
--- a/fs_mgr/libsnapshot/utility.cpp
+++ b/fs_mgr/libsnapshot/utility.cpp
@@ -230,11 +230,7 @@
return fetcher->GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
}
-bool CanUseUserspaceSnapshots() {
- if (!GetUserspaceSnapshotsEnabledProperty()) {
- return false;
- }
-
+bool IsVendorFromAndroid12() {
auto fetcher = IPropertyFetcher::GetInstance();
const std::string UNKNOWN = "unknown";
@@ -243,8 +239,15 @@
// No user-space snapshots if vendor partition is on Android 12
if (vendor_release.find("12") != std::string::npos) {
- LOG(INFO) << "Userspace snapshots disabled as vendor partition is on Android: "
- << vendor_release;
+ return true;
+ }
+
+ return false;
+}
+
+bool CanUseUserspaceSnapshots() {
+ if (!GetUserspaceSnapshotsEnabledProperty()) {
+ LOG(INFO) << "Virtual A/B - Userspace snapshots disabled";
return false;
}
diff --git a/fs_mgr/libsnapshot/utility.h b/fs_mgr/libsnapshot/utility.h
index 370f3c4..f956a05 100644
--- a/fs_mgr/libsnapshot/utility.h
+++ b/fs_mgr/libsnapshot/utility.h
@@ -136,6 +136,7 @@
bool CanUseUserspaceSnapshots();
bool IsDmSnapshotTestingEnabled();
+bool IsVendorFromAndroid12();
// Swap the suffix of a partition name.
std::string GetOtherPartitionName(const std::string& name);
diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 9503072..f55cadb 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -74,6 +74,7 @@
ASSERT_EQ(access("/sys/fs/erofs", F_OK), 0);
}
+// @VsrTest = 3.7.10
TEST(fs, PartitionTypes) {
// Requirements only apply to Android 13+, 5.10+ devices.
int vsr_level = GetVsrLevel();
diff --git a/fs_mgr/tools/dmctl.cpp b/fs_mgr/tools/dmctl.cpp
index 9dc8c24..00f8038 100644
--- a/fs_mgr/tools/dmctl.cpp
+++ b/fs_mgr/tools/dmctl.cpp
@@ -50,8 +50,10 @@
std::cerr << " create <dm-name> [-ro] <targets...>" << std::endl;
std::cerr << " delete <dm-name>" << std::endl;
std::cerr << " list <devices | targets> [-v]" << std::endl;
+ std::cerr << " message <dm-name> <sector> <message>" << std::endl;
std::cerr << " getpath <dm-name>" << std::endl;
std::cerr << " getuuid <dm-name>" << std::endl;
+ std::cerr << " ima <dm-name>" << std::endl;
std::cerr << " info <dm-name>" << std::endl;
std::cerr << " replace <dm-name> <targets...>" << std::endl;
std::cerr << " status <dm-name>" << std::endl;
@@ -202,6 +204,46 @@
return std::make_unique<DmTargetUser>(start_sector, num_sectors, control_device);
} else if (target_type == "error") {
return std::make_unique<DmTargetError>(start_sector, num_sectors);
+ } else if (target_type == "thin-pool") {
+ if (!HasArgs(4)) {
+ std::cerr << "Expected \"thin-pool\" <metadata dev> <data dev> <data block size> "
+ "<low water mark> <feature args>"
+ << std::endl;
+ return nullptr;
+ }
+
+ std::string metadata_dev = NextArg();
+ std::string data_dev = NextArg();
+ std::string data_block_size_str = NextArg();
+ std::string low_water_mark_str = NextArg();
+
+ uint64_t data_block_size;
+ if (!android::base::ParseUint(data_block_size_str, &data_block_size)) {
+ std::cerr << "Data block size must be an unsigned integer.\n";
+ return nullptr;
+ }
+ uint64_t low_water_mark;
+ if (!android::base::ParseUint(low_water_mark_str, &low_water_mark)) {
+ std::cerr << "Low water mark must be an unsigned integer.\n";
+ return nullptr;
+ }
+ return std::make_unique<DmTargetThinPool>(start_sector, num_sectors, metadata_dev,
+ data_dev, data_block_size, low_water_mark);
+ } else if (target_type == "thin") {
+ if (!HasArgs(2)) {
+ std::cerr << "Expected \"thin\" <pool dev> <dev id>" << std::endl;
+ return nullptr;
+ }
+
+ std::string pool_dev = NextArg();
+ std::string dev_id_str = NextArg();
+
+ uint64_t dev_id;
+ if (!android::base::ParseUint(dev_id_str, &dev_id)) {
+ std::cerr << "Dev id must be an unsigned integer.\n";
+ return nullptr;
+ }
+ return std::make_unique<DmTargetThin>(start_sector, num_sectors, pool_dev, dev_id);
} else {
std::cerr << "Unrecognized target type: " << target_type << std::endl;
return nullptr;
@@ -416,6 +458,24 @@
return -EINVAL;
}
+static int DmMessageCmdHandler(int argc, char** argv) {
+ if (argc != 3) {
+ std::cerr << "Usage: dmctl message <name> <sector> <message>" << std::endl;
+ return -EINVAL;
+ }
+ uint64_t sector;
+ if (!android::base::ParseUint(argv[1], §or)) {
+ std::cerr << "Invalid argument for sector: " << argv[1] << std::endl;
+ return -EINVAL;
+ }
+ DeviceMapper& dm = DeviceMapper::Instance();
+ if (!dm.SendMessage(argv[0], sector, argv[2])) {
+ std::cerr << "Could not send message to " << argv[0] << std::endl;
+ return -EINVAL;
+ }
+ return 0;
+}
+
static int HelpCmdHandler(int /* argc */, char** /* argv */) {
Usage();
return 0;
@@ -508,7 +568,14 @@
<< std::endl;
return -EINVAL;
}
+ } else if (mode == "ima") {
+ if (!dm.GetTableStatusIma(argv[0], &table)) {
+ std::cerr << "Could not query table status of device \"" << argv[0] << "\"."
+ << std::endl;
+ return -EINVAL;
+ }
}
+
std::cout << "Targets in the device-mapper table for " << argv[0] << ":" << std::endl;
for (const auto& target : table) {
std::cout << target.spec.sector_start << "-"
@@ -530,6 +597,10 @@
return DumpTable("status", argc, argv);
}
+static int ImaCmdHandler(int argc, char** argv) {
+ return DumpTable("ima", argc, argv);
+}
+
static int ResumeCmdHandler(int argc, char** argv) {
if (argc != 1) {
std::cerr << "Invalid arguments, see \'dmctl help\'" << std::endl;
@@ -564,12 +635,14 @@
{"delete", DmDeleteCmdHandler},
{"replace", DmReplaceCmdHandler},
{"list", DmListCmdHandler},
+ {"message", DmMessageCmdHandler},
{"help", HelpCmdHandler},
{"getpath", GetPathCmdHandler},
{"getuuid", GetUuidCmdHandler},
{"info", InfoCmdHandler},
{"table", TableCmdHandler},
{"status", StatusCmdHandler},
+ {"ima", ImaCmdHandler},
{"resume", ResumeCmdHandler},
{"suspend", SuspendCmdHandler},
// clang-format on
diff --git a/init/Android.bp b/init/Android.bp
index c3abefe..6160a71 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -162,6 +162,7 @@
},
static_libs: [
"libavb",
+ "libavf_cc_flags",
"libbootloader_message",
"libc++fs",
"libcgrouprc_format",
@@ -254,7 +255,11 @@
cc_library_static {
name: "libinit.microdroid",
- defaults: ["libinit_defaults"],
+ defaults: [
+ "avf_build_flags_cc",
+ "libinit_defaults",
+ ],
+ recovery_available: false,
cflags: ["-DMICRODROID=1"],
}
@@ -272,6 +277,13 @@
defaults: ["init_defaults"],
srcs: ["main.cpp"],
symlinks: ["ueventd"],
+}
+
+cc_binary {
+ name: "init_second_stage",
+ defaults: ["init_second_stage_defaults"],
+ static_libs: ["libinit"],
+ visibility: ["//visibility:any_system_partition"],
target: {
platform: {
required: [
@@ -306,17 +318,15 @@
}
cc_binary {
- name: "init_second_stage",
- defaults: ["init_second_stage_defaults"],
- static_libs: ["libinit"],
-}
-
-cc_binary {
name: "init_second_stage.microdroid",
- defaults: ["init_second_stage_defaults"],
+ defaults: [
+ "avf_build_flags_cc",
+ "init_second_stage_defaults",
+ ],
+ recovery_available: false,
static_libs: ["libinit.microdroid"],
cflags: ["-DMICRODROID=1"],
- installable: false,
+ no_full_install: true,
visibility: ["//packages/modules/Virtualization/microdroid"],
}
@@ -359,6 +369,7 @@
static_libs: [
"libc++fs",
"libfs_avb",
+ "libavf_cc_flags",
"libfs_mgr",
"libfec",
"libfec_rs",
@@ -441,6 +452,7 @@
// First stage init is weird: it may start without stdout/stderr, and no /proc.
hwaddress: false,
+ memtag_stack: false,
},
// Install adb_debug.prop into debug ramdisk.
@@ -459,9 +471,12 @@
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,
+ no_full_install: true,
}
phony {
diff --git a/init/README.ueventd.md b/init/README.ueventd.md
index 3c7107a..7d00195 100644
--- a/init/README.ueventd.md
+++ b/init/README.ueventd.md
@@ -59,9 +59,10 @@
`subsystem_name` is used to match uevent `SUBSYSTEM` value
-`devname` takes one of two options
+`devname` takes one of three options
1. `uevent_devname` specifies that the name of the node will be the uevent `DEVNAME`
- 2. `uevent_devpath` specified that the name of the node will be basename uevent `DEVPATH`
+ 2. `uevent_devpath` specifies that the name of the node will be basename uevent `DEVPATH`
+ 3. `sys_name` specifies that the name of the node will be the contents of `/sys/DEVPATH/name`
`dirname` is an optional parameter that specifies a directory within `/dev` where the node will be
created.
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/devices.cpp b/init/devices.cpp
index e76786a..792d8c8 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -25,6 +25,7 @@
#include <filesystem>
#include <memory>
#include <string>
+#include <string_view>
#include <thread>
#include <android-base/chrono_utils.h>
@@ -377,8 +378,8 @@
if (FindPlatformDevice(uevent.path, &device)) {
// Skip /devices/platform or /devices/ if present
- static const std::string devices_platform_prefix = "/devices/platform/";
- static const std::string devices_prefix = "/devices/";
+ static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+ static constexpr std::string_view devices_prefix = "/devices/";
if (StartsWith(device, devices_platform_prefix)) {
device = device.substr(devices_platform_prefix.length());
diff --git a/init/devices.h b/init/devices.h
index f9f4d79..44ce2a9 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -82,6 +82,7 @@
enum DevnameSource {
DEVNAME_UEVENT_DEVNAME,
DEVNAME_UEVENT_DEVPATH,
+ DEVNAME_SYS_NAME,
};
Subsystem() {}
@@ -92,10 +93,18 @@
// Returns the full path for a uevent of a device that is a member of this subsystem,
// according to the rules parsed from ueventd.rc
std::string ParseDevPath(const Uevent& uevent) const {
- std::string devname = devname_source_ == DEVNAME_UEVENT_DEVNAME
- ? uevent.device_name
- : android::base::Basename(uevent.path);
-
+ std::string devname;
+ if (devname_source_ == DEVNAME_UEVENT_DEVNAME) {
+ devname = uevent.device_name;
+ } else if (devname_source_ == DEVNAME_UEVENT_DEVPATH) {
+ devname = android::base::Basename(uevent.path);
+ } else if (devname_source_ == DEVNAME_SYS_NAME) {
+ if (android::base::ReadFileToString("/sys/" + uevent.path + "/name", &devname)) {
+ devname.pop_back(); // Remove terminating newline
+ } else {
+ devname = uevent.device_name;
+ }
+ }
return dir_name_ + "/" + devname;
}
diff --git a/init/firmware_handler.cpp b/init/firmware_handler.cpp
index 3c012fe..01957ef 100644
--- a/init/firmware_handler.cpp
+++ b/init/firmware_handler.cpp
@@ -264,8 +264,9 @@
return uevent.firmware;
}
-void FirmwareHandler::ProcessFirmwareEvent(const std::string& root,
+void FirmwareHandler::ProcessFirmwareEvent(const std::string& path,
const std::string& firmware) const {
+ std::string root = "/sys" + path;
std::string loading = root + "/loading";
std::string data = root + "/data";
@@ -296,6 +297,7 @@
", fstat failed: " + strerror(errno));
return false;
}
+ LOG(INFO) << "found " << file << " for " << path;
LoadFirmware(firmware, root, fw_fd.get(), sb.st_size, loading_fd.get(), data_fd.get());
return true;
};
@@ -362,7 +364,7 @@
if (pid == 0) {
Timer t;
auto firmware = GetFirmwarePath(uevent);
- ProcessFirmwareEvent("/sys" + uevent.path, firmware);
+ ProcessFirmwareEvent(uevent.path, firmware);
LOG(INFO) << "loading " << uevent.path << " took " << t;
_exit(EXIT_SUCCESS);
}
diff --git a/init/firmware_handler.h b/init/firmware_handler.h
index d2f7347..fceb392 100644
--- a/init/firmware_handler.h
+++ b/init/firmware_handler.h
@@ -57,7 +57,7 @@
Result<std::string> RunExternalHandler(const std::string& handler, uid_t uid, gid_t gid,
const Uevent& uevent) const;
std::string GetFirmwarePath(const Uevent& uevent) const;
- void ProcessFirmwareEvent(const std::string& root, const std::string& firmware) const;
+ void ProcessFirmwareEvent(const std::string& path, const std::string& firmware) const;
bool ForEachFirmwareDirectory(std::function<bool(const std::string&)> handler) const;
std::vector<std::string> firmware_directories_;
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index c4d0f75..bfe636b 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);
@@ -402,18 +408,6 @@
LOG(INFO) << "init first stage started!";
- // We only allow /vendor partition in debuggable Microdrod until it is verified during boot.
- // TODO(b/285855436): remove this check.
- if (IsMicrodroid()) {
- bool mount_vendor =
- cmdline.find("androidboot.microdroid.mount_vendor=1") != std::string::npos;
- bool debuggable =
- bootconfig.find("androidboot.microdroid.debuggable = \"1\"") != std::string::npos;
- if (mount_vendor && !debuggable) {
- LOG(FATAL) << "Attempted to mount /vendor partition for non-debuggable Microdroid VM";
- }
- }
-
auto old_root_dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir("/"), closedir};
if (!old_root_dir) {
PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index c0b9281..5d3a273 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_)) {
@@ -381,9 +396,10 @@
use_snapuserd_ = sm->IsSnapuserdRequired();
if (use_snapuserd_) {
if (sm->UpdateUsesUserSnapshots()) {
- LaunchFirstStageSnapuserd(SnapshotDriver::DM_USER);
+ LaunchFirstStageSnapuserd();
} else {
- LaunchFirstStageSnapuserd(SnapshotDriver::DM_SNAPSHOT);
+ LOG(FATAL) << "legacy virtual-ab is no longer supported";
+ return false;
}
}
@@ -527,9 +543,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*, 8> 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", nullptr,
+ };
+ // 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_stubs.h b/init/host_init_stubs.h
index 753ed6b..2fef9d3 100644
--- a/init/host_init_stubs.h
+++ b/init/host_init_stubs.h
@@ -32,6 +32,7 @@
#define __ANDROID_API_S__ 31
#define __ANDROID_API_T__ 33
#define __ANDROID_API_U__ 34
+#define __ANDROID_API_V__ 35
// sys/system_properties.h
#define PROP_VALUE_MAX 92
diff --git a/init/init_test.cpp b/init/init_test.cpp
index 7e8513b..b2f586b 100644
--- a/init/init_test.cpp
+++ b/init/init_test.cpp
@@ -630,7 +630,7 @@
ASSERT_TRUE(parser.ParseConfig(tf.path));
- if (GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_U__) {
+ if (GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
ASSERT_EQ(1u, parser.parse_error_count());
} else {
ASSERT_EQ(0u, parser.parse_error_count());
diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 6f8a4de..1d17e3c 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>
@@ -235,6 +236,9 @@
persistent_properties->mutable_properties()->end(),
[&name](const auto& record) { return record.name() == name; });
if (it != persistent_properties->mutable_properties()->end()) {
+ if (it->value() == value) {
+ return;
+ }
it->set_name(name);
it->set_value(value);
} else {
diff --git a/init/persistent_properties_test.cpp b/init/persistent_properties_test.cpp
index 5763050..97865d7 100644
--- a/init/persistent_properties_test.cpp
+++ b/init/persistent_properties_test.cpp
@@ -17,6 +17,9 @@
#include "persistent_properties.h"
#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
#include <vector>
@@ -155,6 +158,31 @@
EXPECT_FALSE(it == read_back_properties.properties().end());
}
+TEST(persistent_properties, NopUpdateDoesntWriteFile) {
+ TemporaryFile tf;
+ ASSERT_TRUE(tf.fd != -1);
+ persistent_property_filename = tf.path;
+
+ auto last_modified = [&tf]() -> time_t {
+ struct stat buf;
+ EXPECT_EQ(fstat(tf.fd, &buf), 0);
+ return buf.st_mtime;
+ };
+
+ std::vector<std::pair<std::string, std::string>> persistent_properties = {
+ {"persist.sys.locale", "en-US"},
+ {"persist.sys.timezone", "America/Los_Angeles"},
+ };
+ ASSERT_RESULT_OK(
+ WritePersistentPropertyFile(VectorToPersistentProperties(persistent_properties)));
+
+ time_t t = last_modified();
+ sleep(2);
+ WritePersistentProperty("persist.sys.locale", "en-US");
+ // Ensure that the file was not modified
+ ASSERT_EQ(last_modified(), t);
+}
+
TEST(persistent_properties, RejectNonPersistProperty) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 58a0a7f..cd5933d 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -453,6 +453,10 @@
SocketConnection* socket, std::string* error) {
auto lock = std::lock_guard{accept_messages_lock};
if (!accept_messages) {
+ // If we're already shutting down and you're asking us to stop something,
+ // just say we did (https://issuetracker.google.com/336223505).
+ if (msg == "stop") return PROP_SUCCESS;
+
*error = "Received control message after shutdown, ignoring";
return PROP_ERROR_HANDLE_CONTROL_MESSAGE;
}
@@ -970,6 +974,17 @@
std::string build_fingerprint = GetProperty("ro.product.brand", UNKNOWN);
build_fingerprint += '/';
build_fingerprint += GetProperty("ro.product.name", UNKNOWN);
+
+ // should be set in /product/etc/build.prop
+ // when we have a dev option device, and we've switched the kernel to 16kb mode
+ // we use the same system image, but we've switched out the kernel, so make it
+ // visible at a high level
+ bool has16KbDevOption =
+ android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
+ if (has16KbDevOption && getpagesize() == 16384) {
+ build_fingerprint += "_16kb";
+ }
+
build_fingerprint += '/';
build_fingerprint += GetProperty("ro.product.device", UNKNOWN);
build_fingerprint += ':';
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/security.cpp b/init/security.cpp
index 3e15447..a0d63bc 100644
--- a/init/security.cpp
+++ b/init/security.cpp
@@ -114,10 +114,9 @@
return {};
}
#elif defined(__riscv)
- // TODO: sv48 and sv57 have both been added to the kernel, but the kernel
- // still doesn't support more than 24 bits.
- // https://github.com/google/android-riscv64/issues/1
- if (SetMmapRndBitsMin(24, 24, false)) {
+ // riscv64 supports 24 rnd bits with Sv39, and starting with the 6.9 kernel,
+ // 33 bits with Sv48 and Sv57.
+ if (SetMmapRndBitsMin(33, 24, false)) {
return {};
}
#elif defined(__x86_64__)
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 1f211dd..c2d9b8d 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -66,6 +66,7 @@
#include <android-base/result.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
+#include <android/avf_cc_flags.h>
#include <fs_avb/fs_avb.h>
#include <fs_mgr.h>
#include <libgsi/libgsi.h>
@@ -111,97 +112,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();
@@ -793,6 +703,15 @@
SelinuxSetEnforcement();
+ if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+ // We run restorecon of /microdroid_resources while we are still in kernel context to avoid
+ // granting init `tmpfs:file relabelfrom` capability.
+ const int flags = SELINUX_ANDROID_RESTORECON_RECURSE;
+ if (selinux_android_restorecon("/microdroid_resources", flags) == -1) {
+ PLOG(FATAL) << "restorecon of /microdroid_resources failed";
+ }
+ }
+
// We're in the kernel domain and want to transition to the init domain. File systems that
// store SELabels in their xattrs, such as ext4 do not need an explicit restorecon here,
// but other file systems do. In particular, this is needed for ramdisks such as the
diff --git a/init/service.cpp b/init/service.cpp
index eb24dd5..31308a0 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -355,20 +355,35 @@
// If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
// reboot into bootloader or set crashing property
boot_clock::time_point now = boot_clock::now();
+ constexpr const char native_watchdog_reboot_time[] = "persist.init.svc.last_fatal_reboot_epoch";
+ uint64_t throttle_window =
+ std::chrono::duration_cast<std::chrono::seconds>(std::chrono::hours(24)).count();
if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
!was_last_exit_ok_) {
bool boot_completed = GetBoolProperty("sys.boot_completed", false);
if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
if (++crash_count_ > 4) {
- auto exit_reason = boot_completed ?
- "in " + std::to_string(fatal_crash_window_.count()) + " minutes" :
- "before boot completed";
+ auto exit_reason =
+ boot_completed
+ ? "in " + std::to_string(fatal_crash_window_.count()) + " minutes"
+ : "before boot completed";
if (flags_ & SVC_CRITICAL) {
if (!GetBoolProperty("init.svc_debug.no_fatal." + name_, false)) {
- // Aborts into `fatal_reboot_target_'.
- SetFatalRebootTarget(fatal_reboot_target_);
- LOG(FATAL) << "critical process '" << name_ << "' exited 4 times "
- << exit_reason;
+ uint64_t epoch_time =
+ std::chrono::duration_cast<std::chrono::seconds>(
+ std::chrono::system_clock::now().time_since_epoch())
+ .count();
+ // Do not reboot again If it was already initiated in the last 24hrs
+ if (epoch_time - GetIntProperty(native_watchdog_reboot_time, 0) >
+ throttle_window) {
+ SetProperty(native_watchdog_reboot_time, std::to_string(epoch_time));
+ // Aborts into `fatal_reboot_target_'.
+ SetFatalRebootTarget(fatal_reboot_target_);
+ LOG(FATAL) << "critical process '" << name_ << "' exited 4 times "
+ << exit_reason;
+ } else {
+ LOG(INFO) << "Reboot already performed in last 24hrs because of crash.";
+ }
}
} else {
LOG(ERROR) << "process with updatable components '" << name_
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 92e350b..6f3e368 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -680,12 +680,12 @@
}
if (service_->proc_attr_.parsed_uid == std::nullopt) {
- if (android::base::GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_U__) {
+ if (android::base::GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
return Error() << "No user specified for service '" << service_->name()
- << "'. Defaults to root.";
+ << "', so it would have been root.";
} else {
LOG(WARNING) << "No user specified for service '" << service_->name()
- << "'. Defaults to root.";
+ << "', so it is root.";
}
}
diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index dea7af9..9e3ff41 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -62,7 +62,7 @@
static constexpr char kSnapuserdLabel[] = "u:object_r:snapuserd_exec:s0";
static constexpr char kSnapuserdSocketLabel[] = "u:object_r:snapuserd_socket:s0";
-void LaunchFirstStageSnapuserd(SnapshotDriver driver) {
+void LaunchFirstStageSnapuserd() {
SocketDescriptor socket_desc;
socket_desc.name = android::snapshot::kSnapuserdSocket;
socket_desc.type = SOCK_STREAM;
@@ -85,22 +85,13 @@
if (pid == 0) {
socket->Publish();
- if (driver == SnapshotDriver::DM_USER) {
- char arg0[] = "/system/bin/snapuserd";
- char arg1[] = "-user_snapshot";
- char* const argv[] = {arg0, arg1, nullptr};
- if (execv(arg0, argv) < 0) {
- PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
- }
- _exit(127);
- } else {
- char arg0[] = "/system/bin/snapuserd";
- char* const argv[] = {arg0, nullptr};
- if (execv(arg0, argv) < 0) {
- PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
- }
- _exit(127);
+ char arg0[] = "/system/bin/snapuserd";
+ char arg1[] = "-user_snapshot";
+ char* const argv[] = {arg0, arg1, nullptr};
+ if (execv(arg0, argv) < 0) {
+ PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
}
+ _exit(127);
}
auto client = SnapuserdClient::Connect(android::snapshot::kSnapuserdSocket, 10s);
diff --git a/init/snapuserd_transition.h b/init/snapuserd_transition.h
index 557d105..e86e8da 100644
--- a/init/snapuserd_transition.h
+++ b/init/snapuserd_transition.h
@@ -29,13 +29,8 @@
namespace android {
namespace init {
-enum class SnapshotDriver {
- DM_SNAPSHOT,
- DM_USER,
-};
-
// Fork and exec a new copy of snapuserd.
-void LaunchFirstStageSnapuserd(SnapshotDriver driver);
+void LaunchFirstStageSnapuserd();
class SnapuserdSelinuxHelper final {
using SnapshotManager = android::snapshot::SnapshotManager;
diff --git a/init/test_kill_services/Android.bp b/init/test_kill_services/Android.bp
index 37361a8..ada87d8 100644
--- a/init/test_kill_services/Android.bp
+++ b/init/test_kill_services/Android.bp
@@ -10,7 +10,10 @@
cc_test {
name: "init_kill_services_test",
srcs: ["init_kill_services_test.cpp"],
- shared_libs: ["libbase"],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ ],
test_suites: ["general-tests"],
// TODO(b/153565474): switch back to auto-generation
diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 510ad8a..3af92bb 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -18,15 +18,20 @@
#include <android-base/logging.h>
#include <android-base/properties.h>
+#include <hidl/ServiceManagement.h>
#include <iostream>
using ::android::base::GetProperty;
using ::android::base::SetProperty;
using ::android::base::WaitForProperty;
+using ::android::hardware::isHidlSupported;
using std::literals::chrono_literals::operator""s;
void ExpectKillingServiceRecovers(const std::string& service_name) {
+ if (!isHidlSupported() && service_name == "hwservicemanager") {
+ GTEST_SKIP() << "No HIDL support on device so hwservicemanager will not be running";
+ }
LOG(INFO) << "before we say hi to " << service_name << ", I can't have apexd around!";
// b/280514080 - servicemanager will restart apexd, and apexd will restart the
diff --git a/init/test_upgrade_mte/AndroidTest.xml b/init/test_upgrade_mte/AndroidTest.xml
index b89cde8..e08afc0 100644
--- a/init/test_upgrade_mte/AndroidTest.xml
+++ b/init/test_upgrade_mte/AndroidTest.xml
@@ -20,11 +20,13 @@
<target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
<option name="cleanup" value="true" />
<option name="remount-system" value="true" />
- <option name="push" value="mte_upgrade_test.rc->/system/etc/init/mte_upgrade_test.rc" />
- <option name="push" value="mte_upgrade_test_helper->/system/bin/mte_upgrade_test_helper" />
- <option name="push" value="mte_upgrade_test_helper->/data/local/tmp/app_process64" />
+
+ <option name="push-file" key="mte_upgrade_test.rc" value="/system/etc/init/mte_upgrade_test.rc" />
+ <option name="push-file" key="mte_upgrade_test_helper" value="/system/bin/mte_upgrade_test_helper" />
+ <option name="push-file" key="mte_upgrade_test_helper" value="/data/local/tmp/app_process64" />
+ <option name="post-push" value="chmod 644 /system/etc/init/mte_upgrade_test.rc" />
</target_preparer>
<test class="com.android.tradefed.testtype.HostTest" >
<option name="jar" value="mte_upgrade_test.jar" />
</test>
-</configuration>
\ No newline at end of file
+</configuration>
diff --git a/init/test_upgrade_mte/OWNERS b/init/test_upgrade_mte/OWNERS
new file mode 100644
index 0000000..79625df
--- /dev/null
+++ b/init/test_upgrade_mte/OWNERS
@@ -0,0 +1,5 @@
+fmayer@google.com
+
+eugenis@google.com
+mitchp@google.com
+pcc@google.com
diff --git a/init/test_upgrade_mte/mte_upgrade_test_helper.cpp b/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
index 6728cc6..c4b175a 100644
--- a/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
+++ b/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
@@ -22,6 +22,7 @@
#include <sys/prctl.h>
#include <time.h>
#include <unistd.h>
+
#include <memory>
int MaybeDowngrade() {
@@ -65,7 +66,5 @@
// This binary gets run by src/com/android/tests/init/MteUpgradeTest.java, which
// asserts that it crashes as expected.
f[17] = 'x';
- char buf[1];
- read(1, buf, 1);
return 0;
}
diff --git a/init/ueventd_parser.cpp b/init/ueventd_parser.cpp
index d34672e..4395d88 100644
--- a/init/ueventd_parser.cpp
+++ b/init/ueventd_parser.cpp
@@ -218,6 +218,10 @@
subsystem_.devname_source_ = Subsystem::DEVNAME_UEVENT_DEVPATH;
return {};
}
+ if (args[1] == "sys_name") {
+ subsystem_.devname_source_ = Subsystem::DEVNAME_SYS_NAME;
+ return {};
+ }
return Error() << "invalid devname '" << args[1] << "'";
}
diff --git a/init/util.cpp b/init/util.cpp
index e760a59..375e905 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>
@@ -569,6 +570,8 @@
{"--recursive", SELINUX_ANDROID_RESTORECON_RECURSE},
{"--skip-ce", SELINUX_ANDROID_RESTORECON_SKIPCE},
{"--cross-filesystems", SELINUX_ANDROID_RESTORECON_CROSS_FILESYSTEMS},
+ {"--force", SELINUX_ANDROID_RESTORECON_FORCE},
+ {"--data-data", SELINUX_ANDROID_RESTORECON_DATADATA},
{0, 0}};
int flag = 0;
@@ -747,5 +750,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/janitors/OWNERS b/janitors/OWNERS
index a28737e..c25d9e4 100644
--- a/janitors/OWNERS
+++ b/janitors/OWNERS
@@ -3,4 +3,5 @@
cferris@google.com
dwillemsen@google.com
enh@google.com
+maco@google.com
sadafebrahimi@google.com
diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
index 333e61c..67c7514 100644
--- a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -290,6 +290,9 @@
"name" : "fs_write_atomic_int"
},
{
+ "name" : "get_fs_config"
+ },
+ {
"name" : "hashmapCreate"
},
{
@@ -1274,6 +1277,27 @@
"source_file" : "system/core/libcutils/include/cutils/fs.h"
},
{
+ "function_name" : "get_fs_config",
+ "linker_set_key" : "get_fs_config",
+ "parameters" :
+ [
+ {
+ "referenced_type" : "_ZTIPKc"
+ },
+ {
+ "referenced_type" : "_ZTIb"
+ },
+ {
+ "referenced_type" : "_ZTIPKc"
+ },
+ {
+ "referenced_type" : "_ZTIP9fs_config"
+ }
+ ],
+ "return_type" : "_ZTIb",
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
+ },
+ {
"function_name" : "hashmapCreate",
"linker_set_key" : "hashmapCreate",
"parameters" :
@@ -2392,6 +2416,15 @@
},
{
"alignment" : 8,
+ "linker_set_key" : "_ZTIP9fs_config",
+ "name" : "fs_config *",
+ "referenced_type" : "_ZTI9fs_config",
+ "self_type" : "_ZTIP9fs_config",
+ "size" : 8,
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
+ },
+ {
+ "alignment" : 8,
"linker_set_key" : "_ZTIP9str_parms",
"name" : "str_parms *",
"referenced_type" : "_ZTI9str_parms",
@@ -2684,6 +2717,37 @@
"self_type" : "_ZTI5cnode",
"size" : 40,
"source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+ },
+ {
+ "alignment" : 8,
+ "fields" :
+ [
+ {
+ "field_name" : "uid",
+ "referenced_type" : "_ZTIj"
+ },
+ {
+ "field_name" : "gid",
+ "field_offset" : 32,
+ "referenced_type" : "_ZTIj"
+ },
+ {
+ "field_name" : "mode",
+ "field_offset" : 64,
+ "referenced_type" : "_ZTIj"
+ },
+ {
+ "field_name" : "capabilities",
+ "field_offset" : 128,
+ "referenced_type" : "_ZTIm"
+ }
+ ],
+ "linker_set_key" : "_ZTI9fs_config",
+ "name" : "fs_config",
+ "referenced_type" : "_ZTI9fs_config",
+ "self_type" : "_ZTI9fs_config",
+ "size" : 24,
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
}
],
"rvalue_reference_types" : []
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
index f612fb9..f75240c 100644
--- a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -300,6 +300,9 @@
"name" : "fs_write_atomic_int"
},
{
+ "name" : "get_fs_config"
+ },
+ {
"name" : "hashmapCreate"
},
{
@@ -1284,6 +1287,27 @@
"source_file" : "system/core/libcutils/include/cutils/fs.h"
},
{
+ "function_name" : "get_fs_config",
+ "linker_set_key" : "get_fs_config",
+ "parameters" :
+ [
+ {
+ "referenced_type" : "_ZTIPKc"
+ },
+ {
+ "referenced_type" : "_ZTIb"
+ },
+ {
+ "referenced_type" : "_ZTIPKc"
+ },
+ {
+ "referenced_type" : "_ZTIP9fs_config"
+ }
+ ],
+ "return_type" : "_ZTIb",
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
+ },
+ {
"function_name" : "hashmapCreate",
"linker_set_key" : "hashmapCreate",
"parameters" :
@@ -2402,6 +2426,15 @@
},
{
"alignment" : 4,
+ "linker_set_key" : "_ZTIP9fs_config",
+ "name" : "fs_config *",
+ "referenced_type" : "_ZTI9fs_config",
+ "self_type" : "_ZTIP9fs_config",
+ "size" : 4,
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
+ },
+ {
+ "alignment" : 4,
"linker_set_key" : "_ZTIP9str_parms",
"name" : "str_parms *",
"referenced_type" : "_ZTI9str_parms",
@@ -2694,6 +2727,37 @@
"self_type" : "_ZTI5cnode",
"size" : 20,
"source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+ },
+ {
+ "alignment" : 8,
+ "fields" :
+ [
+ {
+ "field_name" : "uid",
+ "referenced_type" : "_ZTIj"
+ },
+ {
+ "field_name" : "gid",
+ "field_offset" : 32,
+ "referenced_type" : "_ZTIj"
+ },
+ {
+ "field_name" : "mode",
+ "field_offset" : 64,
+ "referenced_type" : "_ZTIt"
+ },
+ {
+ "field_name" : "capabilities",
+ "field_offset" : 128,
+ "referenced_type" : "_ZTIy"
+ }
+ ],
+ "linker_set_key" : "_ZTI9fs_config",
+ "name" : "fs_config",
+ "referenced_type" : "_ZTI9fs_config",
+ "self_type" : "_ZTI9fs_config",
+ "size" : 24,
+ "source_file" : "system/core/libcutils/include/private/fs_config.h"
}
],
"rvalue_reference_types" : []
diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 919be2f..5efe209 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -91,7 +91,7 @@
{ 00751, AID_ROOT, AID_SHELL, 0, "vendor/bin" },
{ 00751, AID_ROOT, AID_SHELL, 0, "vendor/apex/*/bin" },
{ 00755, AID_ROOT, AID_SHELL, 0, "vendor" },
- { 00755, AID_ROOT, AID_ROOT, 0, 0 },
+ {},
// clang-format on
};
#ifndef __ANDROID_VNDK__
@@ -218,17 +218,32 @@
{ 00640, AID_ROOT, AID_SHELL, 0, "fstab.*" },
{ 00750, AID_ROOT, AID_SHELL, 0, "init*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "odm/bin/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "odm/framework/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "odm/app/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "odm/priv-app/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "product/bin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "product/apex/*bin/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "product/framework/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "product/app/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "product/priv-app/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system/bin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system/xbin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system/apex/*/bin/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system/framework/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system/app/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system/priv-app/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system_ext/bin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system_ext/apex/*/bin/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system_ext/framework/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system_ext/app/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "system_ext/priv-app/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "vendor/bin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "vendor/apex/*bin/*" },
{ 00755, AID_ROOT, AID_SHELL, 0, "vendor/xbin/*" },
- { 00644, AID_ROOT, AID_ROOT, 0, 0 },
+ { 00644, AID_ROOT, AID_ROOT, 0, "vendor/framework/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "vendor/app/*" },
+ { 00644, AID_ROOT, AID_ROOT, 0, "vendor/priv-app/*" },
+ {},
// clang-format on
};
#ifndef __ANDROID_VNDK__
@@ -318,8 +333,8 @@
auto __for_testing_only__fs_config_cmp = fs_config_cmp;
#endif
-void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
- unsigned* mode, uint64_t* capabilities) {
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+ struct fs_config* fs_conf) {
const struct fs_path_config* pc;
size_t which, plen;
@@ -362,11 +377,11 @@
if (fs_config_cmp(dir, prefix, len, path, plen)) {
free(prefix);
close(fd);
- *uid = header.uid;
- *gid = header.gid;
- *mode = (*mode & (~07777)) | header.mode;
- *capabilities = header.capabilities;
- return;
+ fs_conf->uid = header.uid;
+ fs_conf->gid = header.gid;
+ fs_conf->mode = header.mode;
+ fs_conf->capabilities = header.capabilities;
+ return true;
}
free(prefix);
}
@@ -375,11 +390,28 @@
for (pc = dir ? android_dirs : android_files; pc->prefix; pc++) {
if (fs_config_cmp(dir, pc->prefix, strlen(pc->prefix), path, plen)) {
- break;
+ fs_conf->uid = pc->uid;
+ fs_conf->gid = pc->gid;
+ fs_conf->mode = pc->mode;
+ fs_conf->capabilities = pc->capabilities;
+ return true;
}
}
- *uid = pc->uid;
- *gid = pc->gid;
- *mode = (*mode & (~07777)) | pc->mode;
- *capabilities = pc->capabilities;
+ return false;
+}
+
+void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
+ unsigned* mode, uint64_t* capabilities) {
+ struct fs_config conf;
+ if (get_fs_config(path, dir, target_out_path, &conf)) {
+ *uid = conf.uid;
+ *gid = conf.gid;
+ *mode = (*mode & S_IFMT) | conf.mode;
+ *capabilities = conf.capabilities;
+ } else {
+ *uid = AID_ROOT;
+ *gid = AID_ROOT;
+ *mode = (*mode & S_IFMT) | (dir ? 0755 : 0644);
+ *capabilities = 0;
+ }
}
diff --git a/libcutils/include/private/fs_config.h b/libcutils/include/private/fs_config.h
index 45f46e5..9a727bc 100644
--- a/libcutils/include/private/fs_config.h
+++ b/libcutils/include/private/fs_config.h
@@ -21,8 +21,11 @@
#pragma once
+#include <fcntl.h>
+#include <stdbool.h>
#include <stdint.h>
#include <sys/cdefs.h>
+#include <unistd.h>
#include <linux/capability.h>
@@ -30,17 +33,27 @@
__BEGIN_DECLS
-/*
- * Used in:
- * build/tools/fs_config/fs_config.c
- * build/tools/fs_get_stats/fs_get_stats.c
- * system/extras/ext4_utils/make_ext4fs_main.c
- * external/squashfs-tools/squashfs-tools/android.c
- * system/core/cpio/mkbootfs.c
- * system/core/adb/file_sync_service.cpp
- * system/extras/ext4_utils/canned_fs_config.c
- */
+/* This API is deprecated. New users should call get_fs_config. */
void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
unsigned* mode, uint64_t* capabilities);
+struct fs_config {
+ uid_t uid;
+ gid_t gid;
+ mode_t mode;
+ uint64_t capabilities;
+};
+
+/*
+ * If a file system configuration was found for the specified path, store it to *conf.
+ * Returns whether a file system configuration was found.
+ *
+ * dir: Whether path refers to a directory.
+ * target_out_path: Path to the base directory to read the file system configuration from, or a null
+ * pointer to use the root directory as the base. Host code should pass $ANDROID_PRODUCT_OUT or
+ * equivalent, and device code should pass a null pointer.
+ */
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+ struct fs_config* conf);
+
__END_DECLS
diff --git a/libmodprobe/Android.bp b/libmodprobe/Android.bp
index 1d94a96..12906cc 100644
--- a/libmodprobe/Android.bp
+++ b/libmodprobe/Android.bp
@@ -10,6 +10,7 @@
vendor_available: true,
ramdisk_available: true,
recovery_available: true,
+ vendor_ramdisk_available: true,
host_supported: true,
srcs: [
"libmodprobe.cpp",
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/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 5023c79..1a40da1 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -484,7 +484,11 @@
return false;
}
- if (module_options_[cnd_last].find("load_sequential=1") != std::string::npos) {
+ std::string str = "load_sequential=1";
+ auto it = module_options_[cnd_last].find(str);
+ if (it != std::string::npos) {
+ module_options_[cnd_last].erase(it, it + str.size());
+
if (!LoadWithAliases(cnd_last, true)) {
return false;
}
diff --git a/libpackagelistparser/include/packagelistparser/packagelistparser.h b/libpackagelistparser/include/packagelistparser/packagelistparser.h
index e89cb54..9bd212a 100644
--- a/libpackagelistparser/include/packagelistparser/packagelistparser.h
+++ b/libpackagelistparser/include/packagelistparser/packagelistparser.h
@@ -33,7 +33,10 @@
/** Package name like "com.android.blah". */
char* name;
- /** Package uid like 10014. */
+ /**
+ * Package uid like 10014.
+ * Note that apexes and SDK libraries may have a bogus 0xffffffff value.
+ */
uid_t uid;
/** Package's AndroidManifest.xml debuggable flag. */
diff --git a/libpackagelistparser/packagelistparser.cpp b/libpackagelistparser/packagelistparser.cpp
index 59c3a74..638cc43 100644
--- a/libpackagelistparser/packagelistparser.cpp
+++ b/libpackagelistparser/packagelistparser.cpp
@@ -63,14 +63,13 @@
}
static bool parse_line(const char* path, size_t line_number, const char* line, pkg_info* info) {
- unsigned long uid;
int debuggable;
char* gid_list;
int profileable_from_shell = 0;
-
int fields =
- sscanf(line, "%ms %lu %d %ms %ms %ms %d %ld", &info->name, &uid, &debuggable, &info->data_dir,
- &info->seinfo, &gid_list, &profileable_from_shell, &info->version_code);
+ sscanf(line, "%ms %u %d %ms %ms %ms %d %ld", &info->name, &info->uid,
+ &debuggable, &info->data_dir, &info->seinfo, &gid_list,
+ &profileable_from_shell, &info->version_code);
// Handle the more complicated gids field and free the temporary string.
bool gids_okay = parse_gids(path, line_number, gid_list, info);
@@ -84,14 +83,7 @@
return false;
}
- // Extra validation.
- if (uid > UID_MAX) {
- ALOGE("%s:%zu: uid %lu > UID_MAX", path, line_number, uid);
- return false;
- }
- info->uid = uid;
-
- // Integer to bool conversions.
+ // Convert integers to bools.
info->debuggable = debuggable;
info->profileable_from_shell = profileable_from_shell;
diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index a52fb67..d40be9f 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -2,15 +2,34 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
-cc_defaults {
- name: "libprocessgroup_defaults",
- cpp_std: "gnu++20",
- cflags: [
- "-Wall",
- "-Werror",
- "-Wexit-time-destructors",
- "-Wno-unused-parameter",
+soong_config_module_type {
+ name: "libprocessgroup_flag_aware_cc_defaults",
+ module_type: "cc_defaults",
+ config_namespace: "ANDROID",
+ bool_variables: [
+ "memcg_v2_force_enabled",
+ "cgroup_v2_sys_app_isolation",
],
+ properties: [
+ "cflags",
+ ],
+}
+
+libprocessgroup_flag_aware_cc_defaults {
+ name: "libprocessgroup_build_flags_cc",
+ cpp_std: "gnu++20",
+ soong_config_variables: {
+ memcg_v2_force_enabled: {
+ cflags: [
+ "-DMEMCG_V2_FORCE_ENABLED=true",
+ ],
+ },
+ cgroup_v2_sys_app_isolation: {
+ cflags: [
+ "-DCGROUP_V2_SYS_APP_ISOLATION=true",
+ ],
+ },
+ },
}
cc_library_headers {
@@ -70,7 +89,7 @@
export_header_lib_headers: [
"libprocessgroup_headers",
],
- defaults: ["libprocessgroup_defaults"],
+ defaults: ["libprocessgroup_build_flags_cc"],
apex_available: [
"//apex_available:platform",
"//apex_available:anyapex",
@@ -81,7 +100,7 @@
cc_test {
name: "task_profiles_test",
host_supported: true,
- defaults: ["libprocessgroup_defaults"],
+ defaults: ["libprocessgroup_build_flags_cc"],
srcs: [
"task_profiles_test.cpp",
],
diff --git a/libprocessgroup/build_flags.h b/libprocessgroup/build_flags.h
new file mode 100644
index 0000000..bc3e7df
--- /dev/null
+++ b/libprocessgroup/build_flags.h
@@ -0,0 +1,37 @@
+/*
+ * 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
+
+#ifndef MEMCG_V2_FORCE_ENABLED
+#define MEMCG_V2_FORCE_ENABLED false
+#endif
+
+#ifndef CGROUP_V2_SYS_APP_ISOLATION
+#define CGROUP_V2_SYS_APP_ISOLATION false
+#endif
+
+namespace android::libprocessgroup_flags {
+
+inline consteval bool force_memcg_v2() {
+ return MEMCG_V2_FORCE_ENABLED;
+}
+
+inline consteval bool cgroup_v2_sys_app_isolation() {
+ return CGROUP_V2_SYS_APP_ISOLATION;
+}
+
+} // namespace android::libprocessgroup_flags
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 94d9502..387c104 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -78,14 +78,6 @@
return true;
}
-static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
- return StringPrintf("%s/uid_%u", cgroup, uid);
-}
-
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, pid_t pid) {
- return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
-}
-
static bool CgroupKillAvailable() {
static std::once_flag f;
static bool cgroup_kill_available = false;
@@ -528,8 +520,14 @@
static int KillProcessGroup(
uid_t uid, pid_t initialPid, int signal, bool once = false,
std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
- CHECK_GE(uid, 0);
- CHECK_GT(initialPid, 0);
+ if (uid < 0) {
+ LOG(ERROR) << __func__ << ": invalid UID " << uid;
+ return -1;
+ }
+ if (initialPid <= 0) {
+ LOG(ERROR) << __func__ << ": invalid PID " << initialPid;
+ return -1;
+ }
// Always attempt to send a kill signal to at least the initialPid, at least once, regardless of
// whether its cgroup exists or not. This should only be necessary if a bug results in the
@@ -689,8 +687,14 @@
}
int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl) {
- CHECK_GE(uid, 0);
- CHECK_GT(initialPid, 0);
+ if (uid < 0) {
+ LOG(ERROR) << __func__ << ": invalid UID " << uid;
+ return -1;
+ }
+ if (initialPid <= 0) {
+ LOG(ERROR) << __func__ << ": invalid PID " << initialPid;
+ return -1;
+ }
if (memControl && !UsePerAppMemcg()) {
LOG(ERROR) << "service memory controls are used without per-process memory cgroup support";
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index ea6c247..1e0783a 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -41,8 +41,5 @@
export_header_lib_headers: [
"libprocessgroup_headers",
],
- cflags: [
- "-Wall",
- "-Werror",
- ],
+ defaults: ["libprocessgroup_build_flags_cc"],
}
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 4e44c91..1b26fbc 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -29,7 +29,7 @@
#include <time.h>
#include <unistd.h>
-#include <regex>
+#include <optional>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -43,6 +43,7 @@
#include <processgroup/processgroup.h>
#include <processgroup/setup.h>
+#include "../build_flags.h"
#include "cgroup_descriptor.h"
using android::base::GetUintProperty;
@@ -57,6 +58,8 @@
static constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
+static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
+
static bool ChangeDirModeAndOwner(const std::string& path, mode_t mode, const std::string& uid,
const std::string& gid, bool permissive_mode = false) {
uid_t pw_uid = -1;
@@ -182,6 +185,8 @@
}
}
+static const bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
+
static bool ReadDescriptorsFromFile(const std::string& file_name,
std::map<std::string, CgroupDescriptor>* descriptors) {
std::vector<CgroupDescriptor> result;
@@ -205,22 +210,41 @@
const Json::Value& cgroups = root["Cgroups"];
for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
std::string name = cgroups[i]["Controller"].asString();
+
+ if (force_memcg_v2 && name == "memory") continue;
+
MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
}
}
+ bool memcgv2_present = false;
+ std::string root_path;
if (root.isMember("Cgroups2")) {
const Json::Value& cgroups2 = root["Cgroups2"];
- std::string root_path = cgroups2["Path"].asString();
+ root_path = cgroups2["Path"].asString();
MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
const Json::Value& childGroups = cgroups2["Controllers"];
for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
std::string name = childGroups[i]["Controller"].asString();
+
+ if (force_memcg_v2 && name == "memory") memcgv2_present = true;
+
MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
}
}
+ if (force_memcg_v2 && !memcgv2_present) {
+ LOG(INFO) << "Forcing memcg to v2 hierarchy";
+ Json::Value memcgv2;
+ memcgv2["Controller"] = "memory";
+ memcgv2["NeedsActivation"] = true;
+ memcgv2["Path"] = ".";
+ memcgv2["Optional"] = true; // In case of cgroup_disabled=memory, so we can still boot
+ MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
+ root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
+ }
+
return true;
}
@@ -308,7 +332,8 @@
if (!base::WriteStringToFile(str, path)) {
if (IsOptionalController(controller)) {
- PLOG(INFO) << "Failed to activate optional controller " << controller->name();
+ PLOG(INFO) << "Failed to activate optional controller " << controller->name()
+ << " at " << path;
return true;
}
PLOG(ERROR) << "Failed to activate controller " << controller->name();
@@ -424,6 +449,76 @@
} // namespace cgrouprc
} // namespace android
+static std::optional<bool> MGLRUDisabled() {
+ const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
+ std::string content;
+ if (!android::base::ReadFileToString(file_name, &content)) {
+ PLOG(ERROR) << "Failed to read MGLRU state from " << file_name;
+ return {};
+ }
+
+ return content == "0x0000";
+}
+
+static std::optional<bool> MEMCGDisabled(
+ const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+ std::string cgroup_v2_root = android::cgrouprc::CGROUP_V2_ROOT_DEFAULT;
+ const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+ if (it == descriptors.end()) {
+ LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
+ << "kernel memory use will be higher than intended.";
+ } else if (it->second.controller()->path() != cgroup_v2_root) {
+ cgroup_v2_root = it->second.controller()->path();
+ }
+
+ const std::string file_name = cgroup_v2_root + "/cgroup.controllers";
+ std::string content;
+ if (!android::base::ReadFileToString(file_name, &content)) {
+ PLOG(ERROR) << "Failed to read cgroup controllers from " << file_name;
+ return {};
+ }
+
+ // If we've forced memcg to v2 and it's not available, then it could only have been disabled
+ // on the kernel command line (GKI sets CONFIG_MEMCG).
+ return content.find("memory") == std::string::npos;
+}
+
+static bool CreateV2SubHierarchy(
+ const std::string& path,
+ const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+ using namespace android::cgrouprc;
+
+ const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+ if (cgv2_iter == descriptors.end()) return false;
+ const android::cgrouprc::CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
+
+ if (!Mkdir(path, cgv2_descriptor.mode(), cgv2_descriptor.uid(), cgv2_descriptor.gid())) {
+ PLOG(ERROR) << "Failed to create directory for " << path;
+ return false;
+ }
+
+ // Activate all v2 controllers in path so they can be activated in
+ // children as they are created.
+ for (const auto& [name, descriptor] : descriptors) {
+ const format::CgroupController* controller = descriptor.controller();
+ std::uint32_t flags = controller->flags();
+ if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
+ flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION) {
+ std::string str("+");
+ str += controller->name();
+ if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+ if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+ PLOG(WARNING) << "Activation of cgroup controller " << str << " failed in path "
+ << path;
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+}
+
bool CgroupSetup() {
using namespace android::cgrouprc;
@@ -457,6 +552,32 @@
}
}
+ if (force_memcg_v2) {
+ if (MGLRUDisabled().value_or(false)) {
+ LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
+ << "Global reclaim performance will suffer.";
+ }
+ if (MEMCGDisabled(descriptors).value_or(false)) {
+ LOG(WARNING) << "Memcg forced to v2 hierarchy while memcg is disabled by kernel "
+ << "command line!";
+ }
+ }
+
+ // System / app isolation.
+ // This really belongs in early-init in init.rc, but we cannot use the flag there.
+ if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
+ const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+ const std::string cgroup_v2_root = (it == descriptors.end())
+ ? CGROUP_V2_ROOT_DEFAULT
+ : it->second.controller()->path();
+
+ LOG(INFO) << "Using system/app isolation under: " << cgroup_v2_root;
+ if (!CreateV2SubHierarchy(cgroup_v2_root + "/apps", descriptors) ||
+ !CreateV2SubHierarchy(cgroup_v2_root + "/system", descriptors)) {
+ return false;
+ }
+ }
+
// mkdir <CGROUPS_RC_DIR> 0711 system system
if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 2353cf1..0c2252b 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -33,6 +33,8 @@
#include <json/reader.h>
#include <json/value.h>
+#include <build_flags.h>
+
// To avoid issues in sdk_mac build
#if defined(__ANDROID__)
#include <sys/prctl.h>
@@ -126,11 +128,29 @@
file_v2_name_ = file_v2_name;
}
+static bool isSystemApp(uid_t uid) {
+ return uid < AID_APP_START;
+}
+
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid) {
+ if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
+ if (isSystemApp(uid))
+ return StringPrintf("%s/system/uid_%u", root_cgroup_path, uid);
+ else
+ return StringPrintf("%s/apps/uid_%u", root_cgroup_path, uid);
+ }
+ return StringPrintf("%s/uid_%u", root_cgroup_path, uid);
+}
+
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid) {
+ const std::string uid_path = ConvertUidToPath(root_cgroup_path, uid);
+ return StringPrintf("%s/pid_%d", uid_path.c_str(), pid);
+}
+
bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
if (controller()->version() == 2) {
- // all cgroup v2 attributes use the same process group hierarchy
- *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
- file_name().c_str());
+ const std::string cgroup_path = ConvertUidPidToPath(controller()->path(), uid, pid);
+ *path = cgroup_path + "/" + file_name();
return true;
}
return GetPathForTask(pid, path);
@@ -155,12 +175,14 @@
return true;
}
+// NOTE: This function is for cgroup v2 only
bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
if (path == nullptr) {
return true;
}
- *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
+ const std::string cgroup_path = ConvertUidToPath(controller()->path(), uid);
+ *path = cgroup_path + "/" + file_name();
return true;
}
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 2fa1931..7e3c50d 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -82,8 +82,8 @@
virtual void EnableResourceCaching(ResourceCacheType) {}
virtual void DropResourceCaching(ResourceCacheType) {}
- virtual bool IsValidForProcess(uid_t uid, pid_t pid) const { return false; }
- virtual bool IsValidForTask(pid_t tid) const { return false; }
+ virtual bool IsValidForProcess(uid_t, pid_t) const { return false; }
+ virtual bool IsValidForTask(pid_t) const { return false; }
protected:
enum CacheUseResult { SUCCESS, FAIL, UNUSED };
@@ -109,8 +109,8 @@
const char* Name() const override { return "SetTimerSlack"; }
bool ExecuteForTask(pid_t tid) const override;
- bool IsValidForProcess(uid_t uid, pid_t pid) const override { return true; }
- bool IsValidForTask(pid_t tid) const override { return true; }
+ bool IsValidForProcess(uid_t, pid_t) const override { return true; }
+ bool IsValidForTask(pid_t) const override { return true; }
private:
unsigned long slack_;
@@ -252,3 +252,6 @@
std::map<std::string, std::shared_ptr<TaskProfile>, std::less<>> profiles_;
std::map<std::string, std::unique_ptr<IProfileAttribute>, std::less<>> attributes_;
};
+
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid);
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid);
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index b17e695..d19da2b 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,8 +102,7 @@
public:
ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
~ProfileAttributeMock() override = default;
- void Reset(const CgroupController& controller, const std::string& file_name,
- const std::string& file_v2_name) override {
+ void Reset(const CgroupController&, const std::string&, const std::string&) override {
CHECK(false);
}
const CgroupController* controller() const override {
@@ -111,10 +110,10 @@
return {};
}
const std::string& file_name() const override { return file_name_; }
- bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+ bool GetPathForProcess(uid_t, pid_t pid, std::string* path) const override {
return GetPathForTask(pid, path);
}
- bool GetPathForTask(int tid, std::string* path) const override {
+ bool GetPathForTask(int, std::string* path) const override {
#ifdef __ANDROID__
CHECK(CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, path));
CHECK_GT(path->length(), 0);
diff --git a/libstats/socket_lazy/Android.bp b/libstats/socket_lazy/Android.bp
index b2cd7b2..241e87a 100644
--- a/libstats/socket_lazy/Android.bp
+++ b/libstats/socket_lazy/Android.bp
@@ -7,6 +7,12 @@
cc_library_static {
name: "libstatssocket_lazy",
+ local_include_dirs: [
+ "include",
+ ],
+ export_include_dirs: [
+ "include",
+ ],
header_libs: [
"libstatssocket_headers",
],
@@ -28,7 +34,10 @@
"-Wall",
"-Werror",
],
- test_suites: ["device-tests", "mts-statsd"],
+ test_suites: [
+ "device-tests",
+ "mts-statsd",
+ ],
test_config: "libstatssocket_lazy_test.xml",
// TODO(b/153588990): Remove when the build system properly separates.
// 32bit and 64bit architectures.
diff --git a/libstats/socket_lazy/include/statssocket_lazy.h b/libstats/socket_lazy/include/statssocket_lazy.h
new file mode 100644
index 0000000..7dda0ba
--- /dev/null
+++ b/libstats/socket_lazy/include/statssocket_lazy.h
@@ -0,0 +1,25 @@
+/*
+ * 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
+
+namespace android::statssocket::lazy {
+
+// See if libstatssocket.so is available. Early processes relying on _lazy might not have access
+// to libstatssocket.so when they start before the StatsD APEX is available.
+bool IsAvailable();
+
+} // namespace android::statssocket::lazy
diff --git a/libstats/socket_lazy/libstatssocket_lazy.cpp b/libstats/socket_lazy/libstatssocket_lazy.cpp
index fe94ef2..d907c7e 100644
--- a/libstats/socket_lazy/libstatssocket_lazy.cpp
+++ b/libstats/socket_lazy/libstatssocket_lazy.cpp
@@ -23,8 +23,10 @@
#include "log/log.h"
-#include "stats_event.h"
-#include "stats_socket.h"
+#include <stats_event.h>
+#include <stats_socket.h>
+
+#include "statssocket_lazy.h"
// This file provides a lazy interface to libstatssocket.so to address early boot dependencies.
// Specifically bootanimation, surfaceflinger, and lmkd run before the statsd APEX is loaded and
@@ -77,6 +79,13 @@
return dlopen("libstatssocket.so", dlopen_flags);
}
+namespace android::statssocket::lazy {
+bool IsAvailable() {
+ static const void* handle = LoadLibstatssocket(RTLD_NOW);
+ return handle != nullptr;
+}
+} // namespace android::statssocket::lazy
+
//
// Initialization and symbol binding.
diff --git a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
index 3de6cd7..733f1e4 100644
--- a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
+++ b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
@@ -21,6 +21,8 @@
#include "stats_event.h"
#include "stats_socket.h"
+#include "statssocket_lazy.h"
+
// The tests here are just for the case when libstatssocket.so cannot be loaded by
// libstatssocket_lazy.
class LibstatssocketLazyTest : public ::testing::Test {
@@ -57,3 +59,7 @@
TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsSocket) {
EXPECT_DEATH(AStatsSocket_close(), kLoadFailed);
}
+
+TEST_F(LibstatssocketLazyTest, IsAvailableFalse) {
+ EXPECT_FALSE(android::statssocket::lazy::IsAvailable());
+}
diff --git a/libsysutils/include/sysutils/SocketListener.h b/libsysutils/include/sysutils/SocketListener.h
index 67a691a..a7fd09e 100644
--- a/libsysutils/include/sysutils/SocketListener.h
+++ b/libsysutils/include/sysutils/SocketListener.h
@@ -19,6 +19,7 @@
#include <pthread.h>
#include <unordered_map>
+#include <vector>
#include <sysutils/SocketClient.h>
#include "SocketClientCommand.h"
diff --git a/libutils/Android.bp b/libutils/Android.bp
index 6c0df6f..ba19ace 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -109,7 +109,7 @@
},
},
fuzz_config: {
- cc: ["smoreland@google.com"],
+ cc: ["smoreland@google.com"],
},
}
@@ -267,6 +267,17 @@
"libbase",
"liblog",
],
+ fuzz_config: {
+ cc: [
+ "smoreland@google.com",
+ ],
+ componentid: 128577,
+ description: "The fuzzer targets the APIs of libutils",
+ vector: "local_no_privileges_required",
+ service_privilege: "privileged",
+ users: "multi_user",
+ fuzzed_code_usage: "shipped",
+ },
}
cc_fuzz {
diff --git a/libutils/CallStack.cpp b/libutils/CallStack.cpp
index fe827eb..029f4a7 100644
--- a/libutils/CallStack.cpp
+++ b/libutils/CallStack.cpp
@@ -89,7 +89,8 @@
// The following four functions may be used via weak symbol references from libutils.
// Clients assume that if any of these symbols are available, then deleteStack() is.
-#ifdef WEAKS_AVAILABLE
+// Apple and Windows does not support this, so only compile on other platforms.
+#if !defined(__APPLE__) && !defined(_WIN32)
CallStack::CallStackUPtr CallStack::getCurrentInternal(int ignoreDepth) {
CallStack::CallStackUPtr stack(new CallStack());
@@ -110,6 +111,6 @@
delete stack;
}
-#endif // WEAKS_AVAILABLE
+#endif // !defined(__APPLE__) && !defined(_WIN32)
}; // namespace android
diff --git a/libutils/CallStack_test.cpp b/libutils/CallStack_test.cpp
index 2cfaf61..7afc2c3 100644
--- a/libutils/CallStack_test.cpp
+++ b/libutils/CallStack_test.cpp
@@ -18,10 +18,16 @@
#include <thread>
+#include <android-base/test_utils.h>
#include <android-base/threads.h>
#include <gtest/gtest.h>
#include <utils/CallStack.h>
+#if defined(__ANDROID__)
+#include <log/log.h>
+#include <log/log_read.h>
+#endif
+
__attribute__((__noinline__)) extern "C" void CurrentCaller(android::String8& backtrace) {
android::CallStack cs;
cs.update();
@@ -61,3 +67,38 @@
ASSERT_NE(-1, cs.toString().find("(ThreadBusyWait")) << "Full backtrace:\n" << cs.toString();
}
+
+#if defined(__ANDROID__)
+TEST(CallStackTest, log_stack) {
+ android::CallStack::logStack("callstack_test");
+ auto logger_list = android_logger_list_open(android_name_to_log_id("main"),
+ ANDROID_LOG_NONBLOCK, 1000, getpid());
+ ASSERT_NE(nullptr, logger_list);
+ std::string log;
+ while (true) {
+ log_msg log_msg;
+ auto ret = android_logger_list_read(logger_list, &log_msg);
+ if (ret == -EAGAIN) {
+ break;
+ }
+ ASSERT_GT(ret, 0);
+ if (log_msg.msg() == nullptr) {
+ continue;
+ }
+ // First get the tag.
+ char* msg = &log_msg.msg()[1];
+ if (std::string(msg) != "callstack_test") {
+ continue;
+ }
+ // Now move past the tag.
+ msg = &msg[strlen(msg) + 1];
+ log += msg;
+ log += '\n';
+ }
+ ASSERT_NE("", log) << "No messages found in the log from the test.";
+ // Look for a backtrace line such as:
+ // #00 pc 00000000000536e4 libutils_test (testing::Test::Run()+436)
+ ASSERT_MATCH(log, "#\\d+ pc \\d+");
+ android_logger_list_close(logger_list);
+}
+#endif
diff --git a/libutils/binder/String16_test.cpp b/libutils/binder/String16_test.cpp
index 6f4642e..83cc599 100644
--- a/libutils/binder/String16_test.cpp
+++ b/libutils/binder/String16_test.cpp
@@ -16,6 +16,8 @@
#include <utils/String16.h>
#include <utils/String8.h>
+#include <compare>
+#include <utility>
#include <gtest/gtest.h>
@@ -257,3 +259,45 @@
EXPECT_EQ(NO_MEMORY, s.insert(3, u"", SIZE_MAX));
EXPECT_STR16EQ(u"foo!bar", s.c_str());
}
+
+TEST(String16Test, comparisons) {
+ const char16_t* cstr1 = u"abc";
+ const char16_t* cstr2 = u"def";
+
+ // str1 and str1b will point to different blocks of memory but with equal contents.
+ String16 str1(cstr1);
+ String16 str1b(cstr1);
+ String16 str2(cstr2);
+
+ EXPECT_TRUE((str1 <=> str1b) == 0);
+ EXPECT_FALSE(str1 != str1b);
+ EXPECT_FALSE(str1 < str1b);
+ EXPECT_TRUE(str1 <= str1b);
+ EXPECT_TRUE(str1 == str1b);
+ EXPECT_TRUE(str1 >= str1b);
+ EXPECT_FALSE(str1 > str1b);
+
+ EXPECT_TRUE((str1 <=> str2) < 0);
+ EXPECT_TRUE((str2 <=> str1) > 0);
+ EXPECT_TRUE(str1 != str2);
+ EXPECT_TRUE(str1 < str2);
+ EXPECT_TRUE(str1 <= str2);
+ EXPECT_FALSE(str1 == str2);
+ EXPECT_FALSE(str1 >= str2);
+ EXPECT_FALSE(str1 > str2);
+
+ // Verify that pre-C++20 comparison operators work with a std::pair of a String8, which only
+ // provides <=> in C++20 and up. See b/339775405.
+
+ std::pair<String16, int> pair1(str1, 13);
+ std::pair<String16, int> pair1b(str1b, 13);
+ std::pair<String16, int> pair2(str2, 13);
+
+ EXPECT_TRUE(pair1 == pair1b);
+ EXPECT_FALSE(pair1 < pair1b);
+ EXPECT_FALSE(pair1 > pair1b);
+
+ EXPECT_TRUE(pair1 != pair2);
+ EXPECT_TRUE(pair1 < pair2);
+ EXPECT_FALSE(pair1 > pair2);
+}
diff --git a/libutils/binder/String8_test.cpp b/libutils/binder/String8_test.cpp
index 6f7882a..fc3c329 100644
--- a/libutils/binder/String8_test.cpp
+++ b/libutils/binder/String8_test.cpp
@@ -17,8 +17,10 @@
#define LOG_TAG "String8_test"
#include <log/log.h>
-#include <utils/String8.h>
#include <utils/String16.h>
+#include <utils/String8.h>
+#include <compare>
+#include <utility>
#include <gtest/gtest.h>
@@ -132,3 +134,45 @@
EXPECT_TRUE(s.removeAll("o"));
EXPECT_STREQ("Hell, wrld!", s.c_str());
}
+
+TEST_F(String8Test, comparisons) {
+ const char* cstr1 = "abc";
+ const char* cstr2 = "def";
+
+ // str1 and str1b will point to different blocks of memory but with equal contents.
+ String8 str1(cstr1);
+ String8 str1b(cstr1);
+ String8 str2(cstr2);
+
+ EXPECT_TRUE((str1 <=> str1b) == 0);
+ EXPECT_FALSE(str1 != str1b);
+ EXPECT_FALSE(str1 < str1b);
+ EXPECT_TRUE(str1 <= str1b);
+ EXPECT_TRUE(str1 == str1b);
+ EXPECT_TRUE(str1 >= str1b);
+ EXPECT_FALSE(str1 > str1b);
+
+ EXPECT_TRUE((str1 <=> str2) < 0);
+ EXPECT_TRUE((str2 <=> str1) > 0);
+ EXPECT_TRUE(str1 != str2);
+ EXPECT_TRUE(str1 < str2);
+ EXPECT_TRUE(str1 <= str2);
+ EXPECT_FALSE(str1 == str2);
+ EXPECT_FALSE(str1 >= str2);
+ EXPECT_FALSE(str1 > str2);
+
+ // Verify that pre-C++20 comparison operators work with a std::pair of a String8, which only
+ // provides <=> in C++20 and up. See b/339775405.
+
+ std::pair<String8, int> pair1(str1, 13);
+ std::pair<String8, int> pair1b(str1b, 13);
+ std::pair<String8, int> pair2(str2, 13);
+
+ EXPECT_TRUE(pair1 == pair1b);
+ EXPECT_FALSE(pair1 < pair1b);
+ EXPECT_FALSE(pair1 > pair1b);
+
+ EXPECT_TRUE(pair1 != pair2);
+ EXPECT_TRUE(pair1 < pair2);
+ EXPECT_FALSE(pair1 > pair2);
+}
diff --git a/libutils/binder/include/utils/String16.h b/libutils/binder/include/utils/String16.h
index c713576..867dbac 100644
--- a/libutils/binder/include/utils/String16.h
+++ b/libutils/binder/include/utils/String16.h
@@ -29,6 +29,10 @@
#define HAS_STRING_VIEW
#endif
+#if __cplusplus >= 202002L
+#include <compare>
+#endif
+
// ---------------------------------------------------------------------------
namespace android {
@@ -105,6 +109,9 @@
inline bool operator!=(const String16& other) const;
inline bool operator>=(const String16& other) const;
inline bool operator>(const String16& other) const;
+#if __cplusplus >= 202002L
+ inline std::strong_ordering operator<=>(const String16& other) const;
+#endif
inline bool operator<(const char16_t* other) const;
inline bool operator<=(const char16_t* other) const;
@@ -112,6 +119,9 @@
inline bool operator!=(const char16_t* other) const;
inline bool operator>=(const char16_t* other) const;
inline bool operator>(const char16_t* other) const;
+#if __cplusplus >= 202002L
+ inline std::strong_ordering operator<=>(const char16_t* other) const;
+#endif
inline operator const char16_t*() const;
@@ -334,6 +344,19 @@
return strzcmp16(mString, size(), other.mString, other.size()) > 0;
}
+#if __cplusplus >= 202002L
+inline std::strong_ordering String16::operator<=>(const String16& other) const {
+ int result = strzcmp16(mString, size(), other.mString, other.size());
+ if (result == 0) {
+ return std::strong_ordering::equal;
+ } else if (result < 0) {
+ return std::strong_ordering::less;
+ } else {
+ return std::strong_ordering::greater;
+ }
+}
+#endif
+
inline bool String16::operator<(const char16_t* other) const
{
return strcmp16(mString, other) < 0;
@@ -364,6 +387,19 @@
return strcmp16(mString, other) > 0;
}
+#if __cplusplus >= 202002L
+inline std::strong_ordering String16::operator<=>(const char16_t* other) const {
+ int result = strcmp16(mString, other);
+ if (result == 0) {
+ return std::strong_ordering::equal;
+ } else if (result < 0) {
+ return std::strong_ordering::less;
+ } else {
+ return std::strong_ordering::greater;
+ }
+}
+#endif
+
inline String16::operator const char16_t*() const
{
return mString;
diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
index 6d25072..e0d7588 100644
--- a/libutils/binder/include/utils/String8.h
+++ b/libutils/binder/include/utils/String8.h
@@ -36,6 +36,10 @@
#define HAS_STRING_VIEW
#endif
+#if __cplusplus >= 202002L
+#include <compare>
+#endif
+
// ---------------------------------------------------------------------------
namespace android {
@@ -106,6 +110,9 @@
inline bool operator!=(const String8& other) const;
inline bool operator>=(const String8& other) const;
inline bool operator>(const String8& other) const;
+#if __cplusplus >= 202002L
+ inline std::strong_ordering operator<=>(const String8& other) const;
+#endif
inline bool operator<(const char* other) const;
inline bool operator<=(const char* other) const;
@@ -113,6 +120,9 @@
inline bool operator!=(const char* other) const;
inline bool operator>=(const char* other) const;
inline bool operator>(const char* other) const;
+#if __cplusplus >= 202002L
+ inline std::strong_ordering operator<=>(const char* other) const;
+#endif
inline operator const char*() const;
@@ -302,6 +312,19 @@
return strcmp(mString, other.mString) > 0;
}
+#if __cplusplus >= 202002L
+inline std::strong_ordering String8::operator<=>(const String8& other) const {
+ int result = strcmp(mString, other.mString);
+ if (result == 0) {
+ return std::strong_ordering::equal;
+ } else if (result < 0) {
+ return std::strong_ordering::less;
+ } else {
+ return std::strong_ordering::greater;
+ }
+}
+#endif
+
inline bool String8::operator<(const char* other) const
{
return strcmp(mString, other) < 0;
@@ -332,6 +355,19 @@
return strcmp(mString, other) > 0;
}
+#if __cplusplus >= 202002L
+inline std::strong_ordering String8::operator<=>(const char* other) const {
+ int result = strcmp(mString, other);
+ if (result == 0) {
+ return std::strong_ordering::equal;
+ } else if (result < 0) {
+ return std::strong_ordering::less;
+ } else {
+ return std::strong_ordering::greater;
+ }
+}
+#endif
+
inline String8::operator const char*() const
{
return mString;
diff --git a/libutils/binder/include/utils/TypeHelpers.h b/libutils/binder/include/utils/TypeHelpers.h
index 1554f52..21d9b3d 100644
--- a/libutils/binder/include/utils/TypeHelpers.h
+++ b/libutils/binder/include/utils/TypeHelpers.h
@@ -109,6 +109,11 @@
ANDROID_BASIC_TYPES_TRAITS( float )
ANDROID_BASIC_TYPES_TRAITS( double )
+template<typename T> struct trait_trivial_ctor<T*> { enum { value = true }; };
+template<typename T> struct trait_trivial_dtor<T*> { enum { value = true }; };
+template<typename T> struct trait_trivial_copy<T*> { enum { value = true }; };
+template<typename T> struct trait_trivial_move<T*> { enum { value = true }; };
+
// ---------------------------------------------------------------------------
diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index e87959e..a22737c 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -23,7 +23,7 @@
llndk: {
symbol_file: "libvendorsupport.map.txt",
},
- srcs: ["version_props.c"],
+ srcs: ["version_props.cpp"],
cflags: [
"-Wall",
"-Werror",
@@ -32,6 +32,7 @@
export_include_dirs: ["include"],
shared_libs: [
"liblog",
+ "libbase",
],
}
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
index d365075..3427bc6 100644
--- a/libvendorsupport/include/vendorsupport/api_level.h
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -44,4 +44,22 @@
*/
int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel);
+#if !defined(__ANDROID_VENDOR__)
+/**
+ * @brief Provide vendor API level to system modules.
+ *
+ * @details
+ * Before deprecating VNDK, system modules read ro.vndk.version to find the
+ * API level that vendor image had implemented. With the VNDK deprecation, this
+ * must be replaced with ro.board.api_level. However, there still are devices
+ * keeping old vendor partitions with the new system upgraded. In this case, the
+ * VNDK version can be used as before.
+ * This API is for platform only.
+ *
+ * @return ro.vndk.version if exist. Otherwise fallback to ro.board.api_level.
+ * 0 if none of these properties are found. This is unexpected, though.
+ */
+int AVendorSupport_getVendorApiLevel();
+#endif // __ANDROID_VENDOR__
+
__END_DECLS
diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index b375a2f..cf82fb7 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -14,37 +14,32 @@
#pragma once
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
+// 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. These symbols
+// must be annotated in map.txt files with the `# llndk=YYYYMM` annotation. They also must be marked
+// with `__INTRODUCED_IN_LLNDK(YYYYMM)` in the header files. 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
#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")
-
-// For the vendor libraries, __INTRODUCED_IN must be ignored because they are only for NDKs but not
-// for LLNDKs.
-#undef __INTRODUCED_IN
-#define __INTRODUCED_IN(x)
+// 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__
-// For non-vendor libraries, __INTRODUCED_IN_LLNDK must be ignored because it must not change
-// symbols of NDK or the system side of the treble boundary. It leaves a no-op annotation for ABI
-// analysis.
-#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
- __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
+// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
+// guard the API for __INTRODUCED_IN.
+#if !defined(API_LEVEL_AT_LEAST)
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+ (__builtin_available(android sdk_api_level, *))
+#endif
#endif // __ANDROID_VENDOR__
-
-__END_DECLS
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.cpp
similarity index 79%
rename from libvendorsupport/version_props.c
rename to libvendorsupport/version_props.cpp
index 835828c..ecba899 100644
--- a/libvendorsupport/version_props.c
+++ b/libvendorsupport/version_props.cpp
@@ -16,6 +16,10 @@
#include <log/log.h>
+#if !defined(__ANDROID_VENDOR__)
+#include <android-base/properties.h>
+#endif
+
int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel) {
if (sdkApiLevel < __ANDROID_API_V__) {
return sdkApiLevel;
@@ -39,3 +43,13 @@
ALOGE("Unexpected vendor api level: %d", vendorApiLevel);
return __INVALID_API_LEVEL;
}
+
+#if !defined(__ANDROID_VENDOR__)
+int AVendorSupport_getVendorApiLevel() {
+ int vendorApiLevel = android::base::GetIntProperty("ro.vndk.version", 0);
+ if (vendorApiLevel) {
+ return vendorApiLevel;
+ }
+ return android::base::GetIntProperty("ro.board.api_level", 0);
+}
+#endif // __ANDROID_VENDOR__
diff --git a/mkbootfs/mkbootfs.c b/mkbootfs/mkbootfs.c
index d3922bf..84a0a4e 100644
--- a/mkbootfs/mkbootfs.c
+++ b/mkbootfs/mkbootfs.c
@@ -402,7 +402,7 @@
static void usage(void)
{
fprintf(stderr,
- "Usage: mkbootfs [-n FILE] [-d DIR|-F FILE] DIR...\n"
+ "Usage: mkbootfs [-n FILE] [-d DIR|-f FILE] DIR...\n"
"\n"
"\t-d, --dirname=DIR: fs-config directory\n"
"\t-f, --file=FILE: Canned configuration file\n"
@@ -410,11 +410,11 @@
"\t-n, --nodes=FILE: Dev nodes description file\n"
"\n"
"Dev nodes description:\n"
- "\t[dir|nod] [perms] [uid] [gid] [c|b] [minor] [major]\n"
+ "\t[dir|nod] [perms] [uid] [gid] [c|b] [major] [minor]\n"
"\tExample:\n"
"\t\t# My device nodes\n"
"\t\tdir dev 0755 0 0\n"
- "\t\tnod dev/null 0600 0 0 c 1 5\n"
+ "\t\tnod dev/null 0600 0 0 c 1 3\n"
);
}
@@ -445,11 +445,6 @@
int num_dirs = argc - optind;
argv += optind;
- if (num_dirs <= 0) {
- usage();
- errx(1, "no directories to process?!");
- }
-
while(num_dirs-- > 0){
char *x = strchr(*argv, '=');
if(x != 0) {
diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index c8a3cd6..108c7c2 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -71,3 +71,49 @@
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",
+}
+
+prebuilt_etc {
+ name: "etc_hosts",
+ src: "etc/hosts",
+ filename: "hosts",
+}
+
+prebuilt_etc {
+ name: "init-debug.rc",
+ src: "init-debug.rc",
+ sub_dir: "init",
+}
+
+llndk_libraries_txt {
+ name: "llndk.libraries.txt",
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 7444f96..2394b14 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -3,19 +3,6 @@
$(eval $(call declare-1p-copy-files,system/core/rootdir,))
#######################################
-# init-debug.rc
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := init-debug.rc
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/init
-
-include $(BUILD_PREBUILT)
-
-#######################################
# asan.options
ifneq ($(filter address,$(SANITIZE_TARGET)),)
@@ -85,9 +72,9 @@
EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
ifeq ($(CLANG_COVERAGE),true)
ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
- EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
+ EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang%c-%20m.profraw
else
- EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
+ EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang-%20m.profraw
endif
endif
@@ -223,13 +210,6 @@
$(hide) sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?$(EXPORT_GLOBAL_HWASAN_OPTIONS)?g' $@
$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
-# Append PLATFORM_VNDK_VERSION to base name.
-define append_vndk_version
-$(strip \
- $(basename $(1)).$(PLATFORM_VNDK_VERSION)$(suffix $(1)) \
-)
-endef
-
#######################################
# sanitizer.libraries.txt
include $(CLEAR_VARS)
diff --git a/rootdir/etc/linker.config.json b/rootdir/etc/linker.config.json
index d72ac66..8b3542f 100644
--- a/rootdir/etc/linker.config.json
+++ b/rootdir/etc/linker.config.json
@@ -9,8 +9,6 @@
"libnativehelper.so",
"libnativeloader.so",
"libsigchain.so",
- // TODO(b/122876336): Remove libpac.so once it's migrated to Webview
- "libpac.so",
// TODO(b/120786417 or b/134659294): libicuuc.so
// and libicui18n.so are kept for app compat.
"libicui18n.so",
@@ -32,6 +30,8 @@
],
"provideLibs": [
"libaptX_encoder.so",
- "libaptXHD_encoder.so"
+ "libaptXHD_encoder.so",
+ "libEGL.so",
+ "libGLESv2.so"
]
}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1e0fa9a..5953769 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
@@ -424,16 +425,6 @@
chown system system /proc/pressure/memory
chmod 0664 /proc/pressure/memory
- # qtaguid will limit access to specific data based on group memberships.
- # net_bw_acct grants impersonation of socket owners.
- # net_bw_stats grants access to other apps' detailed tagged-socket stats.
- chown root net_bw_acct /proc/net/xt_qtaguid/ctrl
- chown root net_bw_stats /proc/net/xt_qtaguid/stats
-
- # Allow everybody to read the xt_qtaguid resource tracking misc dev.
- # This is needed by any process that uses socket tagging.
- chmod 0644 /dev/xt_qtaguid
-
mount bpf bpf /sys/fs/bpf nodev noexec nosuid
# pstore/ramoops previous console log
@@ -646,8 +637,12 @@
mkdir /metadata/aconfig 0775 root system
mkdir /metadata/aconfig/flags 0770 root system
+ mkdir /metadata/aconfig/maps 0775 root system
mkdir /metadata/aconfig/boot 0775 root system
+ mkdir /metadata/aconfig_test_missions 0775 root system
+ exec_start aconfigd-platform-init
+
on late-fs
# Ensure that tracefs has the correct permissions.
# This does not work correctly if it is called in post-fs.
@@ -661,10 +656,6 @@
exec -- /system/bin/fsverity_init --load-verified-keys
# Only enable the bootreceiver tracing instance for kernels 5.10 and above.
-on late-fs && property:ro.kernel.version=4.9
- setprop bootreceiver.enable 0
-on late-fs && property:ro.kernel.version=4.14
- setprop bootreceiver.enable 0
on late-fs && property:ro.kernel.version=4.19
setprop bootreceiver.enable 0
on late-fs && property:ro.kernel.version=5.4
@@ -856,6 +847,8 @@
mkdir /data/misc/odsign 0710 root system
# directory used for odsign metrics
mkdir /data/misc/odsign/metrics 0770 root system
+ # directory used for connectivity blob store.
+ mkdir /data/misc/connectivityblobdb 0770 system system
# Directory for VirtualizationService temporary image files.
# Delete any stale files owned by the old virtualizationservice uid (b/230056726).
@@ -877,6 +870,9 @@
mkdir /data/app-lib 0771 system system encryption=Require
mkdir /data/app 0771 system system encryption=Require
+ # Create directory for app metadata files
+ mkdir /data/app-metadata 0700 system system encryption=Require
+
# create directory for updated font files.
mkdir /data/fonts/ 0771 root root encryption=Require
mkdir /data/fonts/files 0771 system system
@@ -965,6 +961,10 @@
mkdir /data/vendor_ce 0551 root root encryption=None
mkdir /data/vendor_de 0551 root root encryption=None
+ # Similar to the top-level CE and DE directories, /data/storage_area must
+ # itself be unencrypted, since it contains encrypted directories.
+ mkdir /data/storage_area 0551 root root encryption=None
+
# Set the casefold flag on /data/media. For upgrades, a restorecon can be
# needed first to relabel the directory from media_rw_data_file.
restorecon /data/media
@@ -978,8 +978,12 @@
mkdir /data_mirror/data_de 0700 root root
mkdir /data_mirror/misc_ce 0700 root root
mkdir /data_mirror/misc_de 0700 root root
+ mkdir /data_mirror/storage_area 0700 root root
# Create CE and DE data directory for default volume
+ # Not needed for storage_area directory, since this is
+ # not supported for non-default volumes and the path
+ # does not include the volume ID
mkdir /data_mirror/data_ce/null 0700 root root
mkdir /data_mirror/data_de/null 0700 root root
mkdir /data_mirror/misc_ce/null 0700 root root
@@ -994,6 +998,9 @@
mount none /data/misc_ce /data_mirror/misc_ce/null bind rec
mount none /data/misc_de /data_mirror/misc_de/null bind rec
+ # Also bind mount for the storage area directory (minus the volume ID)
+ mount none /data/storage_area /data_mirror/storage_area bind rec
+
# Create mirror directory for jit profiles
mkdir /data_mirror/cur_profiles 0700 root root
mount none /data/misc/profiles/cur /data_mirror/cur_profiles bind rec
@@ -1024,9 +1031,11 @@
# Wait for apexd to finish activating APEXes before starting more processes.
wait_for_prop apexd.status activated
perform_apex_config
+ exec_start aconfigd-mainline-init
+ start aconfigd
# Create directories for boot animation.
- mkdir /data/misc/bootanim 0755 system system encryption=DeleteIfNecessary
+ mkdir /data/misc/bootanim 0755 system system
exec_start derive_sdk
@@ -1334,6 +1343,8 @@
umount /data_mirror/data_ce/null/0
umount /data_mirror/data_ce/null
umount /data_mirror/data_de/null
+ umount /data_mirror/storage_area/0
+ umount /data_mirror/storage_area
umount /data_mirror/cur_profiles
umount /data_mirror/ref_profiles
umount /data_mirror
@@ -1361,3 +1372,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/shell_and_utilities/README.md b/shell_and_utilities/README.md
index 9a733bb..c7c622e 100644
--- a/shell_and_utilities/README.md
+++ b/shell_and_utilities/README.md
@@ -37,7 +37,46 @@
full list for a release by running `toybox` directly.
-## Android 14 ("U")
+## Android 15 (API level 35, "Vanilla Ice Cream")
+
+BSD: fsck\_msdos newfs\_msdos
+
+bzip2: bzcat bzip2 bunzip2
+
+gavinhoward/bc: bc
+
+one-true-awk: awk
+
+toolbox: getevent getprop setprop start stop
+
+toybox ([0.8.11](https://landley.net/toybox/news.html#08-04-2024)-ish):
+[ acpi base64 basename blkdiscard blkid blockdev brctl cal cat chattr
+chcon chgrp chmod chown chroot chrt cksum clear cmp comm cp cpio cut
+date dd devmem df diff dirname dmesg dos2unix du echo egrep env expand
+expr fallocate false fgrep file find flock fmt free freeramdisk fsfreeze
+fsync getconf getenforce **getfattr** getopt **gpiodetect** **gpiofind**
+**gpioget** **gpioinfo** **gpioset** grep groups gunzip gzip head help hostname
+hwclock i2cdetect i2cdump i2cget i2cset **i2ctransfer** iconv id ifconfig
+inotifyd insmod install ionice iorenice iotop kill killall ln load\_policy
+log logger logname losetup ls lsattr lsmod lsof lspci lsusb makedevs
+md5sum **memeater** microcom mkdir mkfifo mknod mkswap mktemp modinfo modprobe
+more mount mountpoint mv nbd-client nc netcat netstat nice nl nohup
+nproc nsenter od partprobe paste patch pgrep pidof ping ping6 pivot\_root
+pkill pmap printenv printf prlimit ps pwd pwdx readelf readlink realpath
+renice restorecon rev rfkill rm rmdir rmmod rtcwake runcon sed sendevent
+seq setenforce **setfattr** setsid sha1sum sha224sum sha256sum sha384sum
+sha512sum sleep sort split stat strings stty swapoff swapon sync sysctl
+tac tail tar taskset tee test time timeout top touch tr traceroute
+traceroute6 true truncate tty tunctl uclampset ulimit umount uname
+uniq unix2dos unlink unshare uptime usleep uudecode uuencode uuidgen
+vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
+
+Note: technically getfattr and setfattr were available in earlier versions,
+but the symlinks were missing until this release, so they were only available
+as `toybox getfattr` and `toybox setfattr` rather than directly.
+
+
+## Android 14 (API level 34, "Upside Down Cake")
BSD: fsck\_msdos newfs\_msdos
@@ -71,7 +110,7 @@
vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
-## Android 13 ("T")
+## Android 13 (33, "Tiramisu")
BSD: fsck\_msdos newfs\_msdos
@@ -105,7 +144,7 @@
vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
-## Android 12 ("S")
+## Android 12 (31, "Snow Cone")
BSD: fsck\_msdos newfs\_msdos
@@ -139,7 +178,7 @@
vmstat watch wc which whoami xargs xxd yes zcat
-## Android 11 ("R")
+## Android 11 (API level 30, "Red Velvet Cake")
BSD: fsck\_msdos newfs\_msdos
@@ -173,7 +212,7 @@
whoami xargs xxd yes zcat
-## Android 10 ("Q")
+## Android 10 (API level 29, "Quince Tart")
BSD: grep fsck\_msdos newfs\_msdos
@@ -205,7 +244,7 @@
wc which whoami xargs xxd yes zcat
-## Android 9.0 (Pie)
+## Android 9.0 (API level 28, "Pie")
BSD: dd grep
@@ -232,7 +271,7 @@
which whoami xargs xxd yes zcat
-## Android 8.0 (Oreo)
+## Android 8.0 (API level 26, "Oreo")
BSD: dd grep
@@ -257,7 +296,7 @@
vmstat wc which whoami xargs xxd yes **zcat**
-## Android 7.0 (Nougat)
+## Android 7.0 (API level 24, "Nougat")
BSD: dd grep
@@ -279,7 +318,7 @@
**uptime** usleep vmstat wc which whoami xargs **xxd** yes
-## Android 6.0 (Marshmallow)
+## Android 6.0 (API level 23, "Marshmallow")
BSD: dd du grep
@@ -300,7 +339,7 @@
vmstat wc which whoami xargs yes
-## Android 5.0 (Lollipop)
+## Android 5.0 (API level 21, "Lollipop")
BSD: cat chown cp dd du grep kill ln mv printenv rm rmdir sleep sync
@@ -312,7 +351,7 @@
top touch umount uptime vmstat watchprops wipe
-## Android 4.4 (KitKat)
+## Android 4.4 (API level 19, "KitKat")
BSD: cat cp dd du grep newfs\_msdos
@@ -324,7 +363,7 @@
stop swapoff swapon sync top touch umount uptime vmstat watchprops wipe
-## Android 4.1-4.3 (JellyBean)
+## Android 4.1-4.3 (API level 16, "Jelly Bean")
BSD: cat cp dd du grep newfs\_msdos
@@ -336,7 +375,7 @@
sync top touch umount uptime vmstat watchprops wipe
-## Android 4.0 (IceCreamSandwich)
+## Android 4.0 (API level 14, "Ice Cream Sandwich")
BSD: cat dd newfs\_msdos
@@ -347,7 +386,7 @@
touch umount uptime vmstat watchprops wipe
-## Android 2.3 (Gingerbread)
+## Android 2.3 (API level 9, "Gingerbread")
BSD: cat dd newfs\_msdos
diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 8594ec4..120cc6e 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -69,6 +69,7 @@
name: "toolbox",
defaults: ["toolbox_binary_defaults"],
recovery_available: true,
+ vendor_ramdisk_available: true,
}
cc_binary {
diff --git a/toolbox/OWNERS b/toolbox/OWNERS
index 5e2c581..898ddce 100644
--- a/toolbox/OWNERS
+++ b/toolbox/OWNERS
@@ -1,2 +1,3 @@
include platform/system/core:/janitors/OWNERS
per-file modprobe.c=willmcvicker@google.com,dvander@google.com
+per-file getevent.c=file:platform/frameworks/base:/INPUT_OWNERS
diff --git a/toolbox/getevent.c b/toolbox/getevent.c
index f65bb20..7b896e9 100644
--- a/toolbox/getevent.c
+++ b/toolbox/getevent.c
@@ -441,7 +441,7 @@
if(res < (int)sizeof(*event)) {
if(errno == EINTR)
return 0;
- fprintf(stderr, "could not get event, %s\n", strerror(errno));
+ fprintf(stderr, "could not get inotify events, %s\n", strerror(errno));
return 1;
}
//printf("got %d bytes of event information\n", res);
@@ -664,7 +664,7 @@
if(ufds[i].revents & POLLIN) {
res = read(ufds[i].fd, &event, sizeof(event));
if(res < (int)sizeof(event)) {
- fprintf(stderr, "could not get event\n");
+ fprintf(stderr, "could not get evdev event, %s\n", strerror(errno));
return 1;
}
if(get_time) {
diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 17d4e31..b0e76ea 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -15,6 +15,7 @@
*/
#include <ctype.h>
+#include <fcntl.h>
#include <getopt.h>
#include <stdlib.h>
@@ -27,6 +28,7 @@
#include <modprobe/modprobe.h>
#include <sys/utsname.h>
+#include <unistd.h>
namespace {
@@ -105,6 +107,11 @@
return 0;
}
+std::string GetPageSizeSuffix() {
+ static const size_t page_size = sysconf(_SC_PAGE_SIZE);
+ return android::base::StringPrintf("_%zuk", page_size / 1024);
+}
+
} // anonymous namespace
extern "C" int modprobe_main(int argc, char** argv) {
@@ -112,6 +119,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 +127,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 +152,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;
@@ -229,34 +240,56 @@
// Allow modules to be directly inside /lib/modules
mod_dirs.emplace_back(LIB_MODULES_PREFIX);
}
+ if (getpagesize() != 4096) {
+ struct utsname uts {};
+ if (uname(&uts)) {
+ PLOG(FATAL) << "Failed to get kernel version";
+ }
+ const auto module_dir = android::base::StringPrintf("/lib/modules/%s%s", uts.release,
+ GetPageSizeSuffix().c_str());
+ struct stat st {};
+ if (stat(module_dir.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {
+ mod_dirs.clear();
+ mod_dirs.emplace_back(module_dir);
+ }
+ }
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/toolbox/setprop.cpp b/toolbox/setprop.cpp
index acf8c3e..91edf45 100644
--- a/toolbox/setprop.cpp
+++ b/toolbox/setprop.cpp
@@ -58,7 +58,7 @@
}
}
- if (value.size() >= PROP_VALUE_MAX && !StartsWith(value, "ro.")) {
+ if (value.size() >= PROP_VALUE_MAX && !StartsWith(name, "ro.")) {
std::cerr << "Value '" << value << "' is too long, " << value.size()
<< " bytes vs a max of " << PROP_VALUE_MAX << std::endl;
return EXIT_FAILURE;
diff --git a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
index 6b8f90f..dec64e1 100644
--- a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
+++ b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
@@ -247,6 +247,7 @@
return EXIT_FAILURE;
} else {
printf("done\n");
+ printf("\nNOTE: device reboot may be required before changes take effect.\n");
return EXIT_SUCCESS;
}
}
diff --git a/trusty/keymint/src/keymint_hal_main.rs b/trusty/keymint/src/keymint_hal_main.rs
index eda986a..ef0c598 100644
--- a/trusty/keymint/src/keymint_hal_main.rs
+++ b/trusty/keymint/src/keymint_hal_main.rs
@@ -82,7 +82,7 @@
}
fn main() {
- if let Err(e) = inner_main() {
+ if let Err(HalServiceError(e)) = inner_main() {
panic!("HAL service failed: {:?}", e);
}
}
diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index dabe118..3cf0c05 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -37,7 +37,7 @@
#define BENCH_RESULT_TPL \
"{" \
" \"schema_version\": 3," \
-" \"suite_name\": \"crypto\"," \
+" \"suite_name\": \"tipc\"," \
" \"bench_name\": \"%s\"," \
" \"results\": [" \
" {" \
@@ -1041,7 +1041,7 @@
}
avg /= params->bench;
- fprintf(stderr, BENCH_RESULT_TPL, params->test_name, min, max, avg, cold, min, max, avg, cold);
+ printf(BENCH_RESULT_TPL, params->test_name, min, max, avg, cold, min, max, avg, cold);
return rc;
}
diff --git a/trusty/line-coverage/coverage.cpp b/trusty/line-coverage/coverage.cpp
index 5f7b3a3..e4db59c 100644
--- a/trusty/line-coverage/coverage.cpp
+++ b/trusty/line-coverage/coverage.cpp
@@ -174,7 +174,7 @@
}
uintptr_t* begin = (uintptr_t*)((char *)shm_ + sizeof(struct control));
- bool ret = WriteFully(output_fd, begin, record_len_);
+ bool ret = WriteFully(output_fd, begin, record_len_ - sizeof(struct control));
if(!ret) {
fprintf(stderr, "Coverage write to file failed\n");
}
diff --git a/trusty/secretkeeper/src/hal_main.rs b/trusty/secretkeeper/src/hal_main.rs
index df30493..b31db13 100644
--- a/trusty/secretkeeper/src/hal_main.rs
+++ b/trusty/secretkeeper/src/hal_main.rs
@@ -91,7 +91,7 @@
}
fn main() {
- if let Err(e) = inner_main() {
+ if let Err(HalServiceError(e)) = inner_main() {
panic!("HAL service failed: {:?}", e);
}
}
diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index 67e935e..6cb72d5 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -41,9 +41,13 @@
static const char* trusty_devname;
static const char* rpmb_devname;
static const char* ss_srv_name = STORAGE_DISK_PROXY_PORT;
+static const char* max_file_size_from;
static enum dev_type dev_type = MMC_RPMB;
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
static enum dev_type parse_dev_type(const char* dev_type_name) {
if (!strcmp(dev_type_name, "mmc")) {
return MMC_RPMB;
@@ -58,17 +62,61 @@
}
}
-static const char* _sopts = "hp:d:r:t:";
+static int parse_and_append_file_mapping(const char* file_mapping) {
+ if (file_mapping == NULL) {
+ ALOGE("Provided file mapping is null\n");
+ return -1;
+ }
+ char* file_mapping_dup = strdup(file_mapping);
+ if (file_mapping_dup == NULL) {
+ ALOGE("Couldn't duplicate string: %s\n", file_mapping);
+ return -1;
+ }
+ const char* file_name = strtok(file_mapping_dup, ":");
+ if (file_name == NULL) {
+ ALOGE("No file name found\n");
+ return -1;
+ }
+ const char* backing_storage = strtok(NULL, ":");
+ if (backing_storage == NULL) {
+ ALOGE("No backing storage found\n");
+ return -1;
+ }
+
+ struct storage_mapping_node* new_node = malloc(sizeof(struct storage_mapping_node));
+ if (new_node == NULL) {
+ ALOGE("Couldn't allocate additional storage_mapping_node\n");
+ return -1;
+ }
+ *new_node = (struct storage_mapping_node){.file_name = file_name,
+ .backing_storage = backing_storage,
+ .next = storage_mapping_head,
+ .fd = -1};
+ storage_mapping_head = new_node;
+ return 0;
+}
+
+static const char* _sopts = "hp:d:r:t:m:f:";
static const struct option _lopts[] = {{"help", no_argument, NULL, 'h'},
{"trusty_dev", required_argument, NULL, 'd'},
{"data_path", required_argument, NULL, 'p'},
{"rpmb_dev", required_argument, NULL, 'r'},
{"dev_type", required_argument, NULL, 't'},
+ {"max_file_size_from", required_argument, NULL, 'm'},
+ {"file_storage_mapping", required_argument, NULL, 'f'},
{0, 0, 0, 0}};
static void show_usage_and_exit(int code) {
- ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type>\n");
+ ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type> [-m "
+ "<file>] [-f <file>:<mapping>]\n");
ALOGE("Available dev types: mmc, virt\n");
+ ALOGE("-f = Maps secure storage files like `0` and `persist/0`\n"
+ "to block devices. Storageproxyd will handle creating the\n"
+ "appropriate symlinks in the root datapath.\n");
+ ALOGE("-m = Specifies the max size constraint for file backed storages.\n"
+ "The constraint is chosen by giving a file, this allows for passing a\n"
+ "block device for which a max file size can be queried. File based\n"
+ "storages will be constrained to that size as well.\n");
exit(code);
}
@@ -187,6 +235,7 @@
static void parse_args(int argc, char* argv[]) {
int opt;
int oidx = 0;
+ int rc = 0;
while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) {
switch (opt) {
@@ -210,6 +259,18 @@
}
break;
+ case 'f':
+ rc = parse_and_append_file_mapping(optarg);
+ if (rc < 0) {
+ ALOGE("Failed to parse file mapping: %s\n", optarg);
+ show_usage_and_exit(EXIT_FAILURE);
+ }
+ break;
+
+ case 'm':
+ max_file_size_from = strdup(optarg);
+ break;
+
default:
ALOGE("unrecognized option (%c):\n", opt);
show_usage_and_exit(EXIT_FAILURE);
@@ -225,6 +286,12 @@
ALOGI("storage data root: %s\n", ss_data_root);
ALOGI("trusty dev: %s\n", trusty_devname);
ALOGI("rpmb dev: %s\n", rpmb_devname);
+ ALOGI("File Mappings: \n");
+ const struct storage_mapping_node* curr = storage_mapping_head;
+ for (; curr != NULL; curr = curr->next) {
+ ALOGI("\t%s -> %s\n", curr->file_name, curr->backing_storage);
+ }
+ ALOGI("max file size from: %s\n", max_file_size_from ? max_file_size_from : "(unset)");
}
int main(int argc, char* argv[]) {
@@ -252,7 +319,7 @@
ABinderProcess_startThreadPool();
/* initialize secure storage directory */
- rc = storage_init(ss_data_root);
+ rc = storage_init(ss_data_root, storage_mapping_head, max_file_size_from);
if (rc < 0) return EXIT_FAILURE;
/* open rpmb device */
diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 8c8edb7..6d0c616 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <assert.h>
#include <cutils/properties.h>
#include <errno.h>
#include <fcntl.h>
@@ -39,16 +40,20 @@
#define ALTERNATE_DATA_DIR "alternate/"
/* Maximum file size for filesystem backed storage (i.e. not block dev backed storage) */
-#define MAX_FILE_SIZE (0x10000000000)
+static uint64_t max_file_size = 0x10000000000;
enum sync_state {
SS_UNUSED = -1,
- SS_CLEAN = 0,
- SS_DIRTY = 1,
+ SS_CLEAN = 0,
+ SS_DIRTY = 1,
+ SS_CLEAN_NEED_SYMLINK = 2,
};
static const char *ssdir_name;
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
/*
* Property set to 1 after we have opened a file under ssdir_name. The backing
* files for both TD and TDP are currently located under /data/vendor/ss and can
@@ -75,24 +80,103 @@
uint8_t data[MAX_READ_SIZE];
} read_rsp;
-static uint32_t insert_fd(int open_flags, int fd)
-{
+static uint32_t insert_fd(int open_flags, int fd, struct storage_mapping_node* node) {
uint32_t handle = fd;
if (handle < FD_TBL_SIZE) {
- fd_state[fd] = SS_CLEAN; /* fd clean */
- if (open_flags & O_TRUNC) {
- fd_state[fd] = SS_DIRTY; /* set fd dirty */
- }
+ fd_state[fd] = SS_CLEAN; /* fd clean */
+ if (open_flags & O_TRUNC) {
+ assert(node == NULL);
+ fd_state[fd] = SS_DIRTY; /* set fd dirty */
+ }
+
+ if (node != NULL) {
+ fd_state[fd] = SS_CLEAN_NEED_SYMLINK;
+ }
} else {
ALOGW("%s: untracked fd %u\n", __func__, fd);
if (open_flags & (O_TRUNC | O_CREAT)) {
fs_state = SS_DIRTY;
}
}
+
+ if (node != NULL) {
+ node->fd = fd;
+ }
+
return handle;
}
+static void clear_fd_symlink_status(uint32_t handle, struct storage_mapping_node* entry) {
+ /* Always clear FD, in case fd is not in FD_TBL */
+ entry->fd = -1;
+
+ if (handle >= FD_TBL_SIZE) {
+ ALOGE("%s: untracked fd=%u\n", __func__, handle);
+ return;
+ }
+
+ if (fd_state[handle] == SS_CLEAN_NEED_SYMLINK) {
+ fd_state[handle] = SS_CLEAN;
+ }
+}
+
+static struct storage_mapping_node* get_pending_symlink_mapping(uint32_t handle) {
+ /* Fast lookup failure, is it in FD TBL */
+ if (handle < FD_TBL_SIZE && fd_state[handle] != SS_CLEAN_NEED_SYMLINK) {
+ return NULL;
+ }
+
+ /* Go find our mapping */
+ struct storage_mapping_node* curr = storage_mapping_head;
+ for (; curr != NULL; curr = curr->next) {
+ if (curr->fd == handle) {
+ return curr;
+ }
+ }
+
+ /* Safety check: state inconsistent if we get here with handle inside table range */
+ assert(handle >= FD_TBL_SIZE);
+
+ return NULL;
+};
+
+static int possibly_symlink_and_clear_mapping(uint32_t handle) {
+ struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+ if (entry == NULL) {
+ /* No mappings pending */
+ return 0;
+ }
+
+ /* Create full path */
+ char* path = NULL;
+ int rc = asprintf(&path, "%s/%s", ssdir_name, entry->file_name);
+ if (rc < 0) {
+ ALOGE("%s: asprintf failed\n", __func__);
+ return -1;
+ }
+
+ /* Try and setup the symlinking */
+ ALOGI("Creating symlink %s->%s\n", path, entry->backing_storage);
+ rc = symlink(entry->backing_storage, path);
+ if (rc < 0) {
+ ALOGE("%s: error symlinking %s->%s (%s)\n", __func__, path, entry->backing_storage,
+ strerror(errno));
+ free(path);
+ return rc;
+ }
+ free(path);
+
+ clear_fd_symlink_status(handle, entry);
+
+ return rc;
+}
+
+static bool is_pending_symlink(uint32_t handle) {
+ struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+ return entry != NULL;
+}
+
static int lookup_fd(uint32_t handle, bool dirty)
{
if (dirty) {
@@ -107,6 +191,12 @@
static int remove_fd(uint32_t handle)
{
+ /* Cleanup fd in symlink mapping if it exists */
+ struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+ if (entry != NULL) {
+ entry->fd = -1;
+ }
+
if (handle < FD_TBL_SIZE) {
fd_state[handle] = SS_UNUSED; /* set to uninstalled */
}
@@ -247,11 +337,73 @@
watch_progress(watcher, "done syncing parent");
}
+static struct storage_mapping_node* get_storage_mapping_entry(const char* source) {
+ struct storage_mapping_node* curr = storage_mapping_head;
+ for (; curr != NULL; curr = curr->next) {
+ if (!strcmp(source, curr->file_name)) {
+ ALOGI("Found backing file %s for %s\n", curr->backing_storage, source);
+ return curr;
+ }
+ }
+ return NULL;
+}
+
+static bool is_backing_storage_mapped(const char* source) {
+ const struct storage_mapping_node* curr = storage_mapping_head;
+ for (; curr != NULL; curr = curr->next) {
+ if (!strcmp(source, curr->backing_storage)) {
+ ALOGI("Backed storage mapping exists for %s\n", curr->backing_storage);
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Attempts to open a backed file, if mapped, without creating the symlink. Symlink will be created
+ * later on the first write. This allows us to continue reporting zero read sizes until the first
+ * write. */
+static int open_possibly_mapped_file(const char* short_path, const char* full_path, int open_flags,
+ struct storage_mapping_node** entry) {
+ /* See if mapping exists, report upstream if there is no mapping. */
+ struct storage_mapping_node* mapping_entry = get_storage_mapping_entry(short_path);
+ if (mapping_entry == NULL) {
+ return TEMP_FAILURE_RETRY(open(full_path, open_flags, S_IRUSR | S_IWUSR));
+ }
+
+ /* Check for existence of root path, we don't allow mappings during early boot */
+ struct stat buf = {0};
+ if (stat(ssdir_name, &buf) != 0) {
+ ALOGW("Root path not accessible yet, refuse to open mappings for now.\n");
+ return -1;
+ }
+
+ /* We don't support exclusive opening of mapped files */
+ if (open_flags & O_EXCL) {
+ ALOGE("Requesting exclusive open on backed storage isn't supported: %s\n", full_path);
+ return -1;
+ }
+
+ /* Try and open mapping file */
+ open_flags &= ~(O_CREAT | O_EXCL);
+ ALOGI("%s Attempting to open mapped file: %s\n", __func__, mapping_entry->backing_storage);
+ int fd =
+ TEMP_FAILURE_RETRY(open(mapping_entry->backing_storage, open_flags, S_IRUSR | S_IWUSR));
+ if (fd < 0) {
+ ALOGE("%s Failed to open mapping file: %s\n", __func__, mapping_entry->backing_storage);
+ return -1;
+ }
+
+ /* Let caller know which entry we used for opening */
+ *entry = mapping_entry;
+ return fd;
+}
+
int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
struct watcher* watcher) {
char* path = NULL;
const struct storage_file_open_req *req = r;
struct storage_file_open_resp resp = {0};
+ struct storage_mapping_node* mapping_entry = NULL;
if (req_len < sizeof(*req)) {
ALOGE("%s: invalid request length (%zd < %zd)\n",
@@ -321,14 +473,18 @@
if (req->flags & STORAGE_FILE_OPEN_CREATE_EXCLUSIVE) {
/* create exclusive */
open_flags |= O_CREAT | O_EXCL;
- rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+ /* Look for and attempt opening a mapping, else just do normal open. */
+ rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
} else {
/* try open first */
rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
if (rc == -1 && errno == ENOENT) {
/* then try open with O_CREATE */
open_flags |= O_CREAT;
- rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+ /* Look for and attempt opening a mapping, else just do normal open. */
+ rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
}
}
@@ -356,7 +512,7 @@
/* at this point rc contains storage file fd */
msg->result = STORAGE_NO_ERROR;
- resp.handle = insert_fd(open_flags, rc);
+ resp.handle = insert_fd(open_flags, rc, mapping_entry);
ALOGV("%s: \"%s\": fd = %u: handle = %d\n",
__func__, path, rc, resp.handle);
@@ -433,6 +589,14 @@
goto err_response;
}
+ /* Handle any delayed symlinking for this handle if any */
+ rc = possibly_symlink_and_clear_mapping(req->handle);
+ if (rc < 0) {
+ ALOGE("Failed to symlink storage\n");
+ msg->result = STORAGE_ERR_GENERIC;
+ goto err_response;
+ }
+
int fd = lookup_fd(req->handle, true);
watch_progress(watcher, "writing");
if (write_with_retry(fd, &req->data[0], req_len - sizeof(*req),
@@ -479,6 +643,14 @@
goto err_response;
}
+ /* If this handle has a delayed symlink we should report 0 size reads until first write occurs
+ */
+ if (is_pending_symlink(req->handle)) {
+ ALOGI("Pending symlink: Forcing read result 0.\n");
+ msg->result = STORAGE_NO_ERROR;
+ return ipc_respond(msg, &read_rsp, sizeof(read_rsp.hdr));
+ }
+
int fd = lookup_fd(req->handle, false);
watch_progress(watcher, "reading");
ssize_t read_res = read_with_retry(fd, read_rsp.hdr.data, req->size,
@@ -592,7 +764,7 @@
goto err_response;
}
} else {
- max_size = MAX_FILE_SIZE;
+ max_size = max_file_size;
}
resp.max_size = max_size;
@@ -603,17 +775,79 @@
return ipc_respond(msg, NULL, 0);
}
-int storage_init(const char *dirname)
-{
+int determine_max_file_size(const char* max_file_size_from) {
+ /* Use default if none passed in */
+ if (max_file_size_from == NULL) {
+ ALOGI("No max file source given, continuing to use default: 0x%" PRIx64 "\n",
+ max_file_size);
+ return 0;
+ }
+
+ /* Check that max_file_size_from is part of our mapping list. */
+ if (!is_backing_storage_mapped(max_file_size_from)) {
+ ALOGE("%s: file doesn't match mapped storages (filename=%s)\n", __func__,
+ max_file_size_from);
+ return -1;
+ }
+
+ ALOGI("Using %s to determine max file size.\n", max_file_size_from);
+
+ /* Error if max file size source not found, possible misconfig. */
+ struct stat buf = {0};
+ int rc = stat(max_file_size_from, &buf);
+ if (rc < 0) {
+ ALOGE("%s: error stat'ing file (filename=%s): %s\n", __func__, max_file_size_from,
+ strerror(errno));
+ return -1;
+ }
+
+ /* Currently only support block device as max file size source */
+ if ((buf.st_mode & S_IFMT) != S_IFBLK) {
+ ALOGE("Unsupported max file size source type: %d\n", buf.st_mode);
+ return -1;
+ }
+
+ ALOGI("%s is a block device, determining block device size\n", max_file_size_from);
+ uint64_t max_size = 0;
+ int fd = TEMP_FAILURE_RETRY(open(max_file_size_from, O_RDONLY | O_NONBLOCK));
+ if (fd < 0) {
+ ALOGE("%s: failed to open backing file %s for ioctl: %s\n", __func__, max_file_size_from,
+ strerror(errno));
+ return -1;
+ }
+ rc = ioctl(fd, BLKGETSIZE64, &max_size);
+ if (rc < 0) {
+ ALOGE("%s: error calling ioctl on file (fd=%d): %s\n", __func__, fd, strerror(errno));
+ close(fd);
+ return -1;
+ }
+ close(fd);
+ max_file_size = max_size;
+
+ ALOGI("Using 0x%" PRIx64 " as max file size\n", max_file_size);
+ return 0;
+}
+
+int storage_init(const char* dirname, struct storage_mapping_node* mappings,
+ const char* max_file_size_from) {
/* If there is an active DSU image, use the alternate fs mode. */
alternate_mode = is_gsi_running();
fs_state = SS_CLEAN;
for (uint i = 0; i < FD_TBL_SIZE; i++) {
- fd_state[i] = SS_UNUSED; /* uninstalled */
+ fd_state[i] = SS_UNUSED; /* uninstalled */
}
ssdir_name = dirname;
+
+ storage_mapping_head = mappings;
+
+ /* Set the max file size based on incoming configuration */
+ int rc = determine_max_file_size(max_file_size_from);
+ if (rc < 0) {
+ return rc;
+ }
+
return 0;
}
@@ -623,17 +857,17 @@
watch_progress(watcher, "sync fd table");
/* sync fd table and reset it to clean state first */
for (uint fd = 0; fd < FD_TBL_SIZE; fd++) {
- if (fd_state[fd] == SS_DIRTY) {
- if (fs_state == SS_CLEAN) {
- /* need to sync individual fd */
- rc = fsync(fd);
- if (rc < 0) {
- ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
- return rc;
- }
- }
- fd_state[fd] = SS_CLEAN; /* set to clean */
- }
+ if (fd_state[fd] == SS_DIRTY) {
+ if (fs_state == SS_CLEAN) {
+ /* need to sync individual fd */
+ rc = fsync(fd);
+ if (rc < 0) {
+ ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
+ return rc;
+ }
+ }
+ fd_state[fd] = SS_CLEAN; /* set to clean */
+ }
}
/* check if we need to sync all filesystems */
diff --git a/trusty/storage/proxy/storage.h b/trusty/storage/proxy/storage.h
index f29fdf2..6dbfe37 100644
--- a/trusty/storage/proxy/storage.h
+++ b/trusty/storage/proxy/storage.h
@@ -21,6 +21,14 @@
/* Defined in watchdog.h */
struct watcher;
+/* Is used for managing alternate backing storage, generally will be a block device. */
+struct storage_mapping_node {
+ struct storage_mapping_node* next;
+ const char* file_name;
+ const char* backing_storage;
+ int fd;
+};
+
int storage_file_delete(struct storage_msg* msg, const void* req, size_t req_len,
struct watcher* watcher);
@@ -45,6 +53,7 @@
int storage_file_get_max_size(struct storage_msg* msg, const void* req, size_t req_len,
struct watcher* watcher);
-int storage_init(const char* dirname);
+int storage_init(const char* dirname, struct storage_mapping_node* head,
+ const char* max_file_size_from);
int storage_sync_checkpoint(struct watcher* watcher);
diff --git a/trusty/utils/coverage-controller/controller.cpp b/trusty/utils/coverage-controller/controller.cpp
index 381a452..f5d70b1 100644
--- a/trusty/utils/coverage-controller/controller.cpp
+++ b/trusty/utils/coverage-controller/controller.cpp
@@ -60,6 +60,7 @@
filename.insert(0, output_dir);
android::base::Result<void> res = record_list_[index]->SaveFile(filename);
counters[index]++;
+ WRITE_ONCE(control->read_buffer_cnt, counters[index]);
}
if(complete_cnt == counters[index] &&
!(flags & FLAG_RUN)) {
diff --git a/trusty/utils/coverage-controller/controller.h b/trusty/utils/coverage-controller/controller.h
index f7789bf..841a1ae 100644
--- a/trusty/utils/coverage-controller/controller.h
+++ b/trusty/utils/coverage-controller/controller.h
@@ -35,9 +35,9 @@
struct control {
/* Written by controller, read by instrumented TA */
uint64_t cntrl_flags;
+ uint64_t read_buffer_cnt;
/* Written by instrumented TA, read by controller */
- uint64_t oper_flags;
uint64_t write_buffer_start_count;
uint64_t write_buffer_complete_count;
};
diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index a270087..5e9caaf 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -24,6 +24,7 @@
],
shared_libs: [
"libc",
+ "libcutils",
"liblog",
"libcrypto",
],
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.c b/trusty/utils/rpmb_dev/rpmb_dev.c
index 0a9e6a1..cee3037 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.c
+++ b/trusty/utils/rpmb_dev/rpmb_dev.c
@@ -19,6 +19,7 @@
#include "rpmb_protocol.h"
#include <assert.h>
+#include <cutils/sockets.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
@@ -613,20 +614,24 @@
return EXIT_FAILURE;
}
- cmdres_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ cmdres_sock = android_get_control_socket(socket_path);
if (cmdres_sock < 0) {
- ALOGE("rpmb_dev: Failed to create command/response socket: %s\n", strerror(errno));
- return EXIT_FAILURE;
- }
+ ALOGW("android_get_control_socket(%s) failed, fall back to create it\n", socket_path);
+ cmdres_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (cmdres_sock < 0) {
+ ALOGE("rpmb_dev: Failed to create command/response socket: %s\n", strerror(errno));
+ return EXIT_FAILURE;
+ }
- cmdres_sockaddr.sun_family = AF_UNIX;
- strncpy(cmdres_sockaddr.sun_path, socket_path, sizeof(cmdres_sockaddr.sun_path));
+ cmdres_sockaddr.sun_family = AF_UNIX;
+ strncpy(cmdres_sockaddr.sun_path, socket_path, sizeof(cmdres_sockaddr.sun_path));
- ret = bind(cmdres_sock, (struct sockaddr*)&cmdres_sockaddr, sizeof(struct sockaddr_un));
- if (ret < 0) {
- ALOGE("rpmb_dev: Failed to bind command/response socket: %s: %s\n", socket_path,
- strerror(errno));
- return EXIT_FAILURE;
+ ret = bind(cmdres_sock, (struct sockaddr*)&cmdres_sockaddr, sizeof(struct sockaddr_un));
+ if (ret < 0) {
+ ALOGE("rpmb_dev: Failed to bind command/response socket: %s: %s\n", socket_path,
+ strerror(errno));
+ return EXIT_FAILURE;
+ }
}
ret = listen(cmdres_sock, 1);
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.rc b/trusty/utils/rpmb_dev/rpmb_dev.rc
index 9e203b8..33ec0f2 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.rc
@@ -1,29 +1,34 @@
# RPMB Mock
-on post-fs-data
- mkdir /data/vendor/ss
- chown root system /data/vendor/ss
- chmod 0770 /data/vendor/ss
- rm /data/vendor/ss/rpmb_sock
- start rpmb_mock_init
+on post-fs
+ mkdir /mnt/vendor/persist/ss 0770 root system
+ exec_start rpmb_mock_init
start rpmb_mock
+on post-fs-data
+ mkdir /data/vendor/ss 0770 root system
+ symlink /mnt/vendor/persist/ss /data/vendor/ss/persist
+ chown root system /data/vendor/ss/persist
+ chmod 0770 /data/vendor/ss/persist
+
# Storage proxy
- start storageproxyd
+ restart storageproxyd
-service storageproxyd /vendor/bin/storageproxyd -d /dev/trusty-ipc-dev0 \
- -r /data/vendor/ss/rpmb_sock -p /data/vendor/ss -t sock
- class main
- disabled
- user root
+service storageproxyd /vendor/bin/storageproxyd -d ${ro.hardware.trusty_ipc_dev:-/dev/trusty-ipc-dev0} \
+ -r /dev/socket/rpmb_mock -p /data/vendor/ss -t sock
+ class early_hal
+ user system
+ group system
-service rpmb_mock_init /vendor/bin/rpmb_dev --dev /data/vendor/ss/RPMB_DATA --init --size 2048
+service rpmb_mock_init /vendor/bin/rpmb_dev --dev /mnt/vendor/persist/ss/RPMB_DATA --init --size 2048
disabled
user system
group system
oneshot
-service rpmb_mock /vendor/bin/rpmb_dev --dev /data/vendor/ss/RPMB_DATA --sock /data/vendor/ss/rpmb_sock
+service rpmb_mock /vendor/bin/rpmb_dev --dev /mnt/vendor/persist/ss/RPMB_DATA \
+ --sock rpmb_mock
class main
disabled
user system
group system
+ socket rpmb_mock stream 660 system system