Merge changes from topic "ramdisk"
* changes:
Add e2fsck to fs_config
Make ramdisk_available.
diff --git a/adb/Android.bp b/adb/Android.bp
index 3e8da8a..b39defe 100644
--- a/adb/Android.bp
+++ b/adb/Android.bp
@@ -730,39 +730,3 @@
"fastdeploy/testdata/sample.cd",
],
}
-
-prebuilt_etc {
- name: "com.android.adbd.ld.config.txt",
- src: "apex/ld.config.txt",
- filename: "ld.config.txt",
- installable: false,
-}
-
-apex {
- name: "com.android.adbd",
- manifest: "apex/apex_manifest.json",
-
- binaries: ["adbd"],
- prebuilts: ["com.android.adbd.init.rc", "com.android.adbd.ld.config.txt"],
-
- key: "com.android.adbd.key",
- certificate: ":com.android.adbd.certificate",
-}
-
-apex_key {
- name: "com.android.adbd.key",
- public_key: "apex/com.android.adbd.avbpubkey",
- private_key: "apex/com.android.adbd.pem",
-}
-
-android_app_certificate {
- name: "com.android.adbd.certificate",
- certificate: "apex/com.android.adbd",
-}
-
-prebuilt_etc {
- name: "com.android.adbd.init.rc",
- src: "apex/adbd.rc",
- filename: "init.rc",
- installable: false,
-}
diff --git a/adb/apex/Android.bp b/adb/apex/Android.bp
new file mode 100644
index 0000000..40ea448
--- /dev/null
+++ b/adb/apex/Android.bp
@@ -0,0 +1,49 @@
+apex_defaults {
+ name: "com.android.adbd-defaults",
+
+ binaries: ["adbd"],
+ prebuilts: ["com.android.adbd.init.rc", "com.android.adbd.ld.config.txt"],
+
+ key: "com.android.adbd.key",
+ certificate: ":com.android.adbd.certificate",
+}
+
+apex {
+ name: "com.android.adbd",
+ defaults: ["com.android.adbd-defaults"],
+ manifest: "apex_manifest.json",
+}
+
+// adbd apex with INT_MAX version code, to allow for upgrade/rollback testing.
+apex {
+ name: "test_com.android.adbd",
+ defaults: ["com.android.adbd-defaults"],
+ manifest: "test_apex_manifest.json",
+ file_contexts: ":com.android.adbd-file_contexts",
+ installable: false,
+}
+
+prebuilt_etc {
+ name: "com.android.adbd.ld.config.txt",
+ src: "ld.config.txt",
+ filename: "ld.config.txt",
+ installable: false,
+}
+
+prebuilt_etc {
+ name: "com.android.adbd.init.rc",
+ src: "adbd.rc",
+ filename: "init.rc",
+ installable: false,
+}
+
+apex_key {
+ name: "com.android.adbd.key",
+ public_key: "com.android.adbd.avbpubkey",
+ private_key: "com.android.adbd.pem",
+}
+
+android_app_certificate {
+ name: "com.android.adbd.certificate",
+ certificate: "com.android.adbd",
+}
diff --git a/adb/apex/test_apex_manifest.json b/adb/apex/test_apex_manifest.json
new file mode 100644
index 0000000..7131977
--- /dev/null
+++ b/adb/apex/test_apex_manifest.json
@@ -0,0 +1,4 @@
+{
+ "name": "com.android.adbd",
+ "version": 2147483647
+}
diff --git a/base/include/android-base/logging.h b/base/include/android-base/logging.h
index 7fd0182..cc162cd 100644
--- a/base/include/android-base/logging.h
+++ b/base/include/android-base/logging.h
@@ -115,7 +115,6 @@
void DefaultAborter(const char* abort_message);
-std::string GetDefaultTag();
void SetDefaultTag(const std::string& tag);
// We expose this even though it is the default because a user that wants to
diff --git a/base/liblog_symbols.cpp b/base/liblog_symbols.cpp
index d0e2eaa..d5dfcd2 100644
--- a/base/liblog_symbols.cpp
+++ b/base/liblog_symbols.cpp
@@ -50,6 +50,7 @@
DLSYM(__android_log_default_aborter)
DLSYM(__android_log_set_minimum_priority);
DLSYM(__android_log_get_minimum_priority);
+ DLSYM(__android_log_set_default_tag);
#undef DLSYM
return real_liblog_functions;
@@ -72,6 +73,7 @@
.__android_log_default_aborter = __android_log_default_aborter,
.__android_log_set_minimum_priority = __android_log_set_minimum_priority,
.__android_log_get_minimum_priority = __android_log_get_minimum_priority,
+ .__android_log_set_default_tag = __android_log_set_default_tag,
};
}();
return liblog_functions;
diff --git a/base/liblog_symbols.h b/base/liblog_symbols.h
index c68fff6..d3134e9 100644
--- a/base/liblog_symbols.h
+++ b/base/liblog_symbols.h
@@ -38,6 +38,7 @@
void (*__android_log_default_aborter)(const char* abort_message);
int (*__android_log_set_minimum_priority)(int priority);
int (*__android_log_get_minimum_priority)();
+ void (*__android_log_set_default_tag)(const char* tag);
};
const std::optional<LibLogFunctions>& GetLibLogFunctions();
diff --git a/base/logging.cpp b/base/logging.cpp
index 508871d..1d8ef57 100644
--- a/base/logging.cpp
+++ b/base/logging.cpp
@@ -211,26 +211,27 @@
return aborter;
}
+// Only used for Q fallback.
static std::recursive_mutex& TagLock() {
static auto& tag_lock = *new std::recursive_mutex();
return tag_lock;
}
+// Only used for Q fallback.
static std::string* gDefaultTag;
-std::string GetDefaultTag() {
- std::lock_guard<std::recursive_mutex> lock(TagLock());
- if (gDefaultTag == nullptr) {
- return "";
- }
- return *gDefaultTag;
-}
+
void SetDefaultTag(const std::string& tag) {
- std::lock_guard<std::recursive_mutex> lock(TagLock());
- if (gDefaultTag != nullptr) {
- delete gDefaultTag;
- gDefaultTag = nullptr;
- }
- if (!tag.empty()) {
- gDefaultTag = new std::string(tag);
+ static auto& liblog_functions = GetLibLogFunctions();
+ if (liblog_functions) {
+ liblog_functions->__android_log_set_default_tag(tag.c_str());
+ } else {
+ std::lock_guard<std::recursive_mutex> lock(TagLock());
+ if (gDefaultTag != nullptr) {
+ delete gDefaultTag;
+ gDefaultTag = nullptr;
+ }
+ if (!tag.empty()) {
+ gDefaultTag = new std::string(tag);
+ }
}
}
@@ -574,24 +575,18 @@
const char* message) {
static auto& liblog_functions = GetLibLogFunctions();
auto priority = LogSeverityToPriority(severity);
- if (tag == nullptr) {
- std::lock_guard<std::recursive_mutex> lock(TagLock());
- if (gDefaultTag == nullptr) {
- gDefaultTag = new std::string(getprogname());
- }
-
- if (liblog_functions) {
- __android_logger_data logger_data = {sizeof(__android_logger_data), LOG_ID_DEFAULT, priority,
- gDefaultTag->c_str(), file, line};
- __android_log_write_logger_data(&logger_data, message);
- } else {
- Logger()(DEFAULT, severity, gDefaultTag->c_str(), file, line, message);
- }
+ if (liblog_functions) {
+ __android_logger_data logger_data = {
+ sizeof(__android_logger_data), LOG_ID_DEFAULT, priority, tag, file, line};
+ __android_log_write_logger_data(&logger_data, message);
} else {
- if (liblog_functions) {
- __android_logger_data logger_data = {
- sizeof(__android_logger_data), LOG_ID_DEFAULT, priority, tag, file, line};
- __android_log_write_logger_data(&logger_data, message);
+ if (tag == nullptr) {
+ std::lock_guard<std::recursive_mutex> lock(TagLock());
+ if (gDefaultTag == nullptr) {
+ gDefaultTag = new std::string(getprogname());
+ }
+
+ Logger()(DEFAULT, severity, gDefaultTag->c_str(), file, line, message);
} else {
Logger()(DEFAULT, severity, tag, file, line, message);
}
diff --git a/base/logging_test.cpp b/base/logging_test.cpp
index 8f46196..3a453e6 100644
--- a/base/logging_test.cpp
+++ b/base/logging_test.cpp
@@ -603,21 +603,6 @@
LOG(ERROR) << "foobar";
}
-TEST(logging, SetDefaultTag) {
- constexpr const char* expected_tag = "test_tag";
- constexpr const char* expected_msg = "foobar";
- CapturedStderr cap;
- {
- std::string old_default_tag = android::base::GetDefaultTag();
- android::base::SetDefaultTag(expected_tag);
- android::base::ScopedLogSeverity sls(android::base::LogSeverity::INFO);
- LOG(INFO) << expected_msg;
- android::base::SetDefaultTag(old_default_tag);
- }
- ASSERT_NO_FATAL_FAILURE(
- CheckMessage(cap, android::base::LogSeverity::INFO, expected_msg, expected_tag));
-}
-
TEST(logging, StdioLogger) {
CapturedStderr cap_err;
CapturedStdout cap_out;
diff --git a/debuggerd/libdebuggerd/test/tombstone_test.cpp b/debuggerd/libdebuggerd/test/tombstone_test.cpp
index 9dea7ac..b33adf3 100644
--- a/debuggerd/libdebuggerd/test/tombstone_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_test.cpp
@@ -359,467 +359,3 @@
dump_timestamp(&log_, 0);
ASSERT_STREQ("Timestamp: 1970-01-01 00:00:00+0000\n", amfd_data_.c_str());
}
-
-class MemoryPattern : public unwindstack::Memory {
- public:
- MemoryPattern() = default;
- virtual ~MemoryPattern() = default;
-
- size_t Read(uint64_t, void* dst, size_t size) override {
- uint8_t* data = reinterpret_cast<uint8_t*>(dst);
- for (size_t i = 0; i < size; i++) {
- data[i] = (i % 0xff);
- }
- return size;
- }
-};
-
-TEST_F(TombstoneTest, dump_stack_single_frame) {
- std::vector<unwindstack::FrameData> frames;
- unwindstack::Maps maps;
- MemoryPattern memory;
-
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1000, .pc = 0x301000, .sp = 0x2000});
- dump_stack(&log_, frames, &maps, &memory);
-
- std::string contents;
- ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
- ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &contents));
-
- std::string expected =
-#if defined(__LP64__)
- " 0000000000001f80 0706050403020100\n"
- " 0000000000001f88 0f0e0d0c0b0a0908\n"
- " 0000000000001f90 1716151413121110\n"
- " 0000000000001f98 1f1e1d1c1b1a1918\n"
- " 0000000000001fa0 2726252423222120\n"
- " 0000000000001fa8 2f2e2d2c2b2a2928\n"
- " 0000000000001fb0 3736353433323130\n"
- " 0000000000001fb8 3f3e3d3c3b3a3938\n"
- " 0000000000001fc0 4746454443424140\n"
- " 0000000000001fc8 4f4e4d4c4b4a4948\n"
- " 0000000000001fd0 5756555453525150\n"
- " 0000000000001fd8 5f5e5d5c5b5a5958\n"
- " 0000000000001fe0 6766656463626160\n"
- " 0000000000001fe8 6f6e6d6c6b6a6968\n"
- " 0000000000001ff0 7776757473727170\n"
- " 0000000000001ff8 7f7e7d7c7b7a7978\n"
- " #00 0000000000002000 0706050403020100\n"
- " 0000000000002008 0f0e0d0c0b0a0908\n"
- " 0000000000002010 1716151413121110\n"
- " 0000000000002018 1f1e1d1c1b1a1918\n"
- " 0000000000002020 2726252423222120\n"
- " 0000000000002028 2f2e2d2c2b2a2928\n"
- " 0000000000002030 3736353433323130\n"
- " 0000000000002038 3f3e3d3c3b3a3938\n"
- " 0000000000002040 4746454443424140\n"
- " 0000000000002048 4f4e4d4c4b4a4948\n"
- " 0000000000002050 5756555453525150\n"
- " 0000000000002058 5f5e5d5c5b5a5958\n"
- " 0000000000002060 6766656463626160\n"
- " 0000000000002068 6f6e6d6c6b6a6968\n"
- " 0000000000002070 7776757473727170\n"
- " 0000000000002078 7f7e7d7c7b7a7978\n";
-#else
- " 00001fc0 03020100\n"
- " 00001fc4 07060504\n"
- " 00001fc8 0b0a0908\n"
- " 00001fcc 0f0e0d0c\n"
- " 00001fd0 13121110\n"
- " 00001fd4 17161514\n"
- " 00001fd8 1b1a1918\n"
- " 00001fdc 1f1e1d1c\n"
- " 00001fe0 23222120\n"
- " 00001fe4 27262524\n"
- " 00001fe8 2b2a2928\n"
- " 00001fec 2f2e2d2c\n"
- " 00001ff0 33323130\n"
- " 00001ff4 37363534\n"
- " 00001ff8 3b3a3938\n"
- " 00001ffc 3f3e3d3c\n"
- " #00 00002000 03020100\n"
- " 00002004 07060504\n"
- " 00002008 0b0a0908\n"
- " 0000200c 0f0e0d0c\n"
- " 00002010 13121110\n"
- " 00002014 17161514\n"
- " 00002018 1b1a1918\n"
- " 0000201c 1f1e1d1c\n"
- " 00002020 23222120\n"
- " 00002024 27262524\n"
- " 00002028 2b2a2928\n"
- " 0000202c 2f2e2d2c\n"
- " 00002030 33323130\n"
- " 00002034 37363534\n"
- " 00002038 3b3a3938\n"
- " 0000203c 3f3e3d3c\n";
-#endif
- EXPECT_EQ(expected, contents);
-}
-
-TEST_F(TombstoneTest, dump_stack_multiple_frames_same_sp) {
- std::vector<unwindstack::FrameData> frames;
- unwindstack::Maps maps;
- MemoryPattern memory;
-
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1000, .pc = 0x301000, .sp = 0x2000});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x2000});
- dump_stack(&log_, frames, &maps, &memory);
-
- std::string contents;
- ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
- ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &contents));
-
- std::string expected =
-#if defined(__LP64__)
- " 0000000000001f80 0706050403020100\n"
- " 0000000000001f88 0f0e0d0c0b0a0908\n"
- " 0000000000001f90 1716151413121110\n"
- " 0000000000001f98 1f1e1d1c1b1a1918\n"
- " 0000000000001fa0 2726252423222120\n"
- " 0000000000001fa8 2f2e2d2c2b2a2928\n"
- " 0000000000001fb0 3736353433323130\n"
- " 0000000000001fb8 3f3e3d3c3b3a3938\n"
- " 0000000000001fc0 4746454443424140\n"
- " 0000000000001fc8 4f4e4d4c4b4a4948\n"
- " 0000000000001fd0 5756555453525150\n"
- " 0000000000001fd8 5f5e5d5c5b5a5958\n"
- " 0000000000001fe0 6766656463626160\n"
- " 0000000000001fe8 6f6e6d6c6b6a6968\n"
- " 0000000000001ff0 7776757473727170\n"
- " 0000000000001ff8 7f7e7d7c7b7a7978\n"
- " #00 0000000000002000 0706050403020100\n"
- " ................ ................\n"
- " #01 0000000000002000 0706050403020100\n"
- " 0000000000002008 0f0e0d0c0b0a0908\n"
- " 0000000000002010 1716151413121110\n"
- " 0000000000002018 1f1e1d1c1b1a1918\n"
- " 0000000000002020 2726252423222120\n"
- " 0000000000002028 2f2e2d2c2b2a2928\n"
- " 0000000000002030 3736353433323130\n"
- " 0000000000002038 3f3e3d3c3b3a3938\n"
- " 0000000000002040 4746454443424140\n"
- " 0000000000002048 4f4e4d4c4b4a4948\n"
- " 0000000000002050 5756555453525150\n"
- " 0000000000002058 5f5e5d5c5b5a5958\n"
- " 0000000000002060 6766656463626160\n"
- " 0000000000002068 6f6e6d6c6b6a6968\n"
- " 0000000000002070 7776757473727170\n"
- " 0000000000002078 7f7e7d7c7b7a7978\n";
-#else
- " 00001fc0 03020100\n"
- " 00001fc4 07060504\n"
- " 00001fc8 0b0a0908\n"
- " 00001fcc 0f0e0d0c\n"
- " 00001fd0 13121110\n"
- " 00001fd4 17161514\n"
- " 00001fd8 1b1a1918\n"
- " 00001fdc 1f1e1d1c\n"
- " 00001fe0 23222120\n"
- " 00001fe4 27262524\n"
- " 00001fe8 2b2a2928\n"
- " 00001fec 2f2e2d2c\n"
- " 00001ff0 33323130\n"
- " 00001ff4 37363534\n"
- " 00001ff8 3b3a3938\n"
- " 00001ffc 3f3e3d3c\n"
- " #00 00002000 03020100\n"
- " ........ ........\n"
- " #01 00002000 03020100\n"
- " 00002004 07060504\n"
- " 00002008 0b0a0908\n"
- " 0000200c 0f0e0d0c\n"
- " 00002010 13121110\n"
- " 00002014 17161514\n"
- " 00002018 1b1a1918\n"
- " 0000201c 1f1e1d1c\n"
- " 00002020 23222120\n"
- " 00002024 27262524\n"
- " 00002028 2b2a2928\n"
- " 0000202c 2f2e2d2c\n"
- " 00002030 33323130\n"
- " 00002034 37363534\n"
- " 00002038 3b3a3938\n"
- " 0000203c 3f3e3d3c\n";
-#endif
- EXPECT_EQ(expected, contents);
-}
-
-TEST_F(TombstoneTest, dump_stack_multiple_frames) {
- std::vector<unwindstack::FrameData> frames;
- unwindstack::Maps maps;
- MemoryPattern memory;
-
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1000, .pc = 0x301000, .sp = 0x2000});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x2010});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x2100});
- dump_stack(&log_, frames, &maps, &memory);
-
- std::string contents;
- ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
- ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &contents));
-
- std::string expected =
-#if defined(__LP64__)
- " 0000000000001f80 0706050403020100\n"
- " 0000000000001f88 0f0e0d0c0b0a0908\n"
- " 0000000000001f90 1716151413121110\n"
- " 0000000000001f98 1f1e1d1c1b1a1918\n"
- " 0000000000001fa0 2726252423222120\n"
- " 0000000000001fa8 2f2e2d2c2b2a2928\n"
- " 0000000000001fb0 3736353433323130\n"
- " 0000000000001fb8 3f3e3d3c3b3a3938\n"
- " 0000000000001fc0 4746454443424140\n"
- " 0000000000001fc8 4f4e4d4c4b4a4948\n"
- " 0000000000001fd0 5756555453525150\n"
- " 0000000000001fd8 5f5e5d5c5b5a5958\n"
- " 0000000000001fe0 6766656463626160\n"
- " 0000000000001fe8 6f6e6d6c6b6a6968\n"
- " 0000000000001ff0 7776757473727170\n"
- " 0000000000001ff8 7f7e7d7c7b7a7978\n"
- " #00 0000000000002000 0706050403020100\n"
- " 0000000000002008 0f0e0d0c0b0a0908\n"
- " #01 0000000000002010 0706050403020100\n"
- " 0000000000002018 0f0e0d0c0b0a0908\n"
- " 0000000000002020 1716151413121110\n"
- " 0000000000002028 1f1e1d1c1b1a1918\n"
- " 0000000000002030 2726252423222120\n"
- " 0000000000002038 2f2e2d2c2b2a2928\n"
- " 0000000000002040 3736353433323130\n"
- " 0000000000002048 3f3e3d3c3b3a3938\n"
- " 0000000000002050 4746454443424140\n"
- " 0000000000002058 4f4e4d4c4b4a4948\n"
- " 0000000000002060 5756555453525150\n"
- " 0000000000002068 5f5e5d5c5b5a5958\n"
- " 0000000000002070 6766656463626160\n"
- " 0000000000002078 6f6e6d6c6b6a6968\n"
- " 0000000000002080 7776757473727170\n"
- " 0000000000002088 7f7e7d7c7b7a7978\n"
- " ................ ................\n"
- " #02 0000000000002100 0706050403020100\n"
- " 0000000000002108 0f0e0d0c0b0a0908\n"
- " 0000000000002110 1716151413121110\n"
- " 0000000000002118 1f1e1d1c1b1a1918\n"
- " 0000000000002120 2726252423222120\n"
- " 0000000000002128 2f2e2d2c2b2a2928\n"
- " 0000000000002130 3736353433323130\n"
- " 0000000000002138 3f3e3d3c3b3a3938\n"
- " 0000000000002140 4746454443424140\n"
- " 0000000000002148 4f4e4d4c4b4a4948\n"
- " 0000000000002150 5756555453525150\n"
- " 0000000000002158 5f5e5d5c5b5a5958\n"
- " 0000000000002160 6766656463626160\n"
- " 0000000000002168 6f6e6d6c6b6a6968\n"
- " 0000000000002170 7776757473727170\n"
- " 0000000000002178 7f7e7d7c7b7a7978\n";
-#else
- " 00001fc0 03020100\n"
- " 00001fc4 07060504\n"
- " 00001fc8 0b0a0908\n"
- " 00001fcc 0f0e0d0c\n"
- " 00001fd0 13121110\n"
- " 00001fd4 17161514\n"
- " 00001fd8 1b1a1918\n"
- " 00001fdc 1f1e1d1c\n"
- " 00001fe0 23222120\n"
- " 00001fe4 27262524\n"
- " 00001fe8 2b2a2928\n"
- " 00001fec 2f2e2d2c\n"
- " 00001ff0 33323130\n"
- " 00001ff4 37363534\n"
- " 00001ff8 3b3a3938\n"
- " 00001ffc 3f3e3d3c\n"
- " #00 00002000 03020100\n"
- " 00002004 07060504\n"
- " 00002008 0b0a0908\n"
- " 0000200c 0f0e0d0c\n"
- " #01 00002010 03020100\n"
- " 00002014 07060504\n"
- " 00002018 0b0a0908\n"
- " 0000201c 0f0e0d0c\n"
- " 00002020 13121110\n"
- " 00002024 17161514\n"
- " 00002028 1b1a1918\n"
- " 0000202c 1f1e1d1c\n"
- " 00002030 23222120\n"
- " 00002034 27262524\n"
- " 00002038 2b2a2928\n"
- " 0000203c 2f2e2d2c\n"
- " 00002040 33323130\n"
- " 00002044 37363534\n"
- " 00002048 3b3a3938\n"
- " 0000204c 3f3e3d3c\n"
- " ........ ........\n"
- " #02 00002100 03020100\n"
- " 00002104 07060504\n"
- " 00002108 0b0a0908\n"
- " 0000210c 0f0e0d0c\n"
- " 00002110 13121110\n"
- " 00002114 17161514\n"
- " 00002118 1b1a1918\n"
- " 0000211c 1f1e1d1c\n"
- " 00002120 23222120\n"
- " 00002124 27262524\n"
- " 00002128 2b2a2928\n"
- " 0000212c 2f2e2d2c\n"
- " 00002130 33323130\n"
- " 00002134 37363534\n"
- " 00002138 3b3a3938\n"
- " 0000213c 3f3e3d3c\n";
-#endif
- EXPECT_EQ(expected, contents);
-}
-
-TEST_F(TombstoneTest, dump_stack_multiple_frames_disjoint_frames) {
- std::vector<unwindstack::FrameData> frames;
- unwindstack::Maps maps;
- MemoryPattern memory;
-
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1000, .pc = 0x301000, .sp = 0x2000});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x2010});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x1000});
- frames.push_back(
- unwindstack::FrameData{.num = 0, .rel_pc = 0x1400, .pc = 0x301400, .sp = 0x1030});
- dump_stack(&log_, frames, &maps, &memory);
-
- std::string contents;
- ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
- ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &contents));
-
- std::string expected =
-#if defined(__LP64__)
- " 0000000000001f80 0706050403020100\n"
- " 0000000000001f88 0f0e0d0c0b0a0908\n"
- " 0000000000001f90 1716151413121110\n"
- " 0000000000001f98 1f1e1d1c1b1a1918\n"
- " 0000000000001fa0 2726252423222120\n"
- " 0000000000001fa8 2f2e2d2c2b2a2928\n"
- " 0000000000001fb0 3736353433323130\n"
- " 0000000000001fb8 3f3e3d3c3b3a3938\n"
- " 0000000000001fc0 4746454443424140\n"
- " 0000000000001fc8 4f4e4d4c4b4a4948\n"
- " 0000000000001fd0 5756555453525150\n"
- " 0000000000001fd8 5f5e5d5c5b5a5958\n"
- " 0000000000001fe0 6766656463626160\n"
- " 0000000000001fe8 6f6e6d6c6b6a6968\n"
- " 0000000000001ff0 7776757473727170\n"
- " 0000000000001ff8 7f7e7d7c7b7a7978\n"
- " #00 0000000000002000 0706050403020100\n"
- " 0000000000002008 0f0e0d0c0b0a0908\n"
- " #01 0000000000002010 0706050403020100\n"
- " 0000000000002018 0f0e0d0c0b0a0908\n"
- " 0000000000002020 1716151413121110\n"
- " 0000000000002028 1f1e1d1c1b1a1918\n"
- " 0000000000002030 2726252423222120\n"
- " 0000000000002038 2f2e2d2c2b2a2928\n"
- " 0000000000002040 3736353433323130\n"
- " 0000000000002048 3f3e3d3c3b3a3938\n"
- " 0000000000002050 4746454443424140\n"
- " 0000000000002058 4f4e4d4c4b4a4948\n"
- " 0000000000002060 5756555453525150\n"
- " 0000000000002068 5f5e5d5c5b5a5958\n"
- " 0000000000002070 6766656463626160\n"
- " 0000000000002078 6f6e6d6c6b6a6968\n"
- " 0000000000002080 7776757473727170\n"
- " 0000000000002088 7f7e7d7c7b7a7978\n"
- " ................ ................\n"
- " #02 0000000000001000 0706050403020100\n"
- " 0000000000001008 0f0e0d0c0b0a0908\n"
- " 0000000000001010 1716151413121110\n"
- " 0000000000001018 1f1e1d1c1b1a1918\n"
- " 0000000000001020 2726252423222120\n"
- " 0000000000001028 2f2e2d2c2b2a2928\n"
- " #03 0000000000001030 0706050403020100\n"
- " 0000000000001038 0f0e0d0c0b0a0908\n"
- " 0000000000001040 1716151413121110\n"
- " 0000000000001048 1f1e1d1c1b1a1918\n"
- " 0000000000001050 2726252423222120\n"
- " 0000000000001058 2f2e2d2c2b2a2928\n"
- " 0000000000001060 3736353433323130\n"
- " 0000000000001068 3f3e3d3c3b3a3938\n"
- " 0000000000001070 4746454443424140\n"
- " 0000000000001078 4f4e4d4c4b4a4948\n"
- " 0000000000001080 5756555453525150\n"
- " 0000000000001088 5f5e5d5c5b5a5958\n"
- " 0000000000001090 6766656463626160\n"
- " 0000000000001098 6f6e6d6c6b6a6968\n"
- " 00000000000010a0 7776757473727170\n"
- " 00000000000010a8 7f7e7d7c7b7a7978\n";
-#else
- " 00001fc0 03020100\n"
- " 00001fc4 07060504\n"
- " 00001fc8 0b0a0908\n"
- " 00001fcc 0f0e0d0c\n"
- " 00001fd0 13121110\n"
- " 00001fd4 17161514\n"
- " 00001fd8 1b1a1918\n"
- " 00001fdc 1f1e1d1c\n"
- " 00001fe0 23222120\n"
- " 00001fe4 27262524\n"
- " 00001fe8 2b2a2928\n"
- " 00001fec 2f2e2d2c\n"
- " 00001ff0 33323130\n"
- " 00001ff4 37363534\n"
- " 00001ff8 3b3a3938\n"
- " 00001ffc 3f3e3d3c\n"
- " #00 00002000 03020100\n"
- " 00002004 07060504\n"
- " 00002008 0b0a0908\n"
- " 0000200c 0f0e0d0c\n"
- " #01 00002010 03020100\n"
- " 00002014 07060504\n"
- " 00002018 0b0a0908\n"
- " 0000201c 0f0e0d0c\n"
- " 00002020 13121110\n"
- " 00002024 17161514\n"
- " 00002028 1b1a1918\n"
- " 0000202c 1f1e1d1c\n"
- " 00002030 23222120\n"
- " 00002034 27262524\n"
- " 00002038 2b2a2928\n"
- " 0000203c 2f2e2d2c\n"
- " 00002040 33323130\n"
- " 00002044 37363534\n"
- " 00002048 3b3a3938\n"
- " 0000204c 3f3e3d3c\n"
- " ........ ........\n"
- " #02 00001000 03020100\n"
- " 00001004 07060504\n"
- " 00001008 0b0a0908\n"
- " 0000100c 0f0e0d0c\n"
- " 00001010 13121110\n"
- " 00001014 17161514\n"
- " 00001018 1b1a1918\n"
- " 0000101c 1f1e1d1c\n"
- " 00001020 23222120\n"
- " 00001024 27262524\n"
- " 00001028 2b2a2928\n"
- " 0000102c 2f2e2d2c\n"
- " #03 00001030 03020100\n"
- " 00001034 07060504\n"
- " 00001038 0b0a0908\n"
- " 0000103c 0f0e0d0c\n"
- " 00001040 13121110\n"
- " 00001044 17161514\n"
- " 00001048 1b1a1918\n"
- " 0000104c 1f1e1d1c\n"
- " 00001050 23222120\n"
- " 00001054 27262524\n"
- " 00001058 2b2a2928\n"
- " 0000105c 2f2e2d2c\n"
- " 00001060 33323130\n"
- " 00001064 37363534\n"
- " 00001068 3b3a3938\n"
- " 0000106c 3f3e3d3c\n";
-#endif
- EXPECT_EQ(expected, contents);
-}
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index b64e260..4e7f35c 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -188,106 +188,6 @@
_LOG(log, logtype::HEADER, "uid: %d\n", thread_info.uid);
}
-static void dump_stack_segment(log_t* log, unwindstack::Maps* maps, unwindstack::Memory* memory,
- uint64_t* sp, size_t words, int label) {
- // Read the data all at once.
- word_t stack_data[words];
-
- // TODO: Do we need to word align this for crashes caused by a misaligned sp?
- // The process_vm_readv implementation of Memory should handle this appropriately?
- size_t bytes_read = memory->Read(*sp, stack_data, sizeof(word_t) * words);
- words = bytes_read / sizeof(word_t);
- std::string line;
- for (size_t i = 0; i < words; i++) {
- line = " ";
- if (i == 0 && label >= 0) {
- // Print the label once.
- line += StringPrintf("#%02d ", label);
- } else {
- line += " ";
- }
- line += StringPrintf("%" PRIPTR " %" PRIPTR, *sp, static_cast<uint64_t>(stack_data[i]));
-
- unwindstack::MapInfo* map_info = maps->Find(stack_data[i]);
- if (map_info != nullptr && !map_info->name.empty()) {
- line += " " + map_info->name;
- std::string func_name;
- uint64_t func_offset = 0;
- if (map_info->GetFunctionName(stack_data[i], &func_name, &func_offset)) {
- line += " (" + func_name;
- if (func_offset) {
- line += StringPrintf("+%" PRIu64, func_offset);
- }
- line += ')';
- }
- }
- _LOG(log, logtype::STACK, "%s\n", line.c_str());
-
- *sp += sizeof(word_t);
- }
-}
-
-static void dump_stack(log_t* log, const std::vector<unwindstack::FrameData>& frames,
- unwindstack::Maps* maps, unwindstack::Memory* memory) {
- size_t first = 0, last;
- for (size_t i = 0; i < frames.size(); i++) {
- if (frames[i].sp) {
- if (!first) {
- first = i+1;
- }
- last = i;
- }
- }
-
- if (!first) {
- return;
- }
- first--;
-
- // Dump a few words before the first frame.
- uint64_t sp = frames[first].sp - STACK_WORDS * sizeof(word_t);
- dump_stack_segment(log, maps, memory, &sp, STACK_WORDS, -1);
-
-#if defined(__LP64__)
- static constexpr const char delimiter[] = " ................ ................\n";
-#else
- static constexpr const char delimiter[] = " ........ ........\n";
-#endif
-
- // Dump a few words from all successive frames.
- for (size_t i = first; i <= last; i++) {
- auto* frame = &frames[i];
- if (sp != frame->sp) {
- _LOG(log, logtype::STACK, delimiter);
- sp = frame->sp;
- }
- if (i != last) {
- // Print stack data up to the stack from the next frame.
- size_t words;
- uint64_t next_sp = frames[i + 1].sp;
- if (next_sp < sp) {
- // The next frame is probably using a completely different stack,
- // so dump the max from this stack.
- words = STACK_WORDS;
- } else {
- words = (next_sp - sp) / sizeof(word_t);
- if (words == 0) {
- // The sp is the same as the next frame, print at least
- // one line for this frame.
- words = 1;
- } else if (words > STACK_WORDS) {
- words = STACK_WORDS;
- }
- }
- dump_stack_segment(log, maps, memory, &sp, words, i);
- } else {
- // Print some number of words past the last stack frame since we
- // don't know how large the stack is.
- dump_stack_segment(log, maps, memory, &sp, STACK_WORDS, i);
- }
- }
-}
-
static std::string get_addr_string(uint64_t addr) {
std::string addr_str;
#if defined(__LP64__)
@@ -499,9 +399,6 @@
} else {
_LOG(log, logtype::BACKTRACE, "\nbacktrace:\n");
log_backtrace(log, unwinder, " ");
-
- _LOG(log, logtype::STACK, "\nstack:\n");
- dump_stack(log, unwinder->frames(), unwinder->GetMaps(), unwinder->GetProcessMemory().get());
}
if (primary_thread) {
diff --git a/fastboot/Android.mk b/fastboot/Android.mk
index 17ec392..fd009e7 100644
--- a/fastboot/Android.mk
+++ b/fastboot/Android.mk
@@ -18,9 +18,9 @@
# Package fastboot-related executables.
#
-my_dist_files := $(HOST_OUT_EXECUTABLES)/mke2fs
-my_dist_files += $(HOST_OUT_EXECUTABLES)/e2fsdroid
-my_dist_files += $(HOST_OUT_EXECUTABLES)/make_f2fs
-my_dist_files += $(HOST_OUT_EXECUTABLES)/sload_f2fs
+my_dist_files := $(SOONG_HOST_OUT_EXECUTABLES)/mke2fs
+my_dist_files += $(SOONG_HOST_OUT_EXECUTABLES)/e2fsdroid
+my_dist_files += $(SOONG_HOST_OUT_EXECUTABLES)/make_f2fs
+my_dist_files += $(SOONG_HOST_OUT_EXECUTABLES)/sload_f2fs
$(call dist-for-goals,dist_files sdk win_sdk,$(my_dist_files))
my_dist_files :=
diff --git a/fastboot/constants.h b/fastboot/constants.h
index 5a554a0..aefd448 100644
--- a/fastboot/constants.h
+++ b/fastboot/constants.h
@@ -47,6 +47,8 @@
#define FB_VAR_VERSION "version"
#define FB_VAR_VERSION_BOOTLOADER "version-bootloader"
#define FB_VAR_VERSION_BASEBAND "version-baseband"
+#define FB_VAR_VERSION_OS "version-os"
+#define FB_VAR_VERSION_VNDK "version-vndk"
#define FB_VAR_PRODUCT "product"
#define FB_VAR_SERIALNO "serialno"
#define FB_VAR_SECURE "secure"
@@ -69,3 +71,9 @@
#define FB_VAR_SUPER_PARTITION_NAME "super-partition-name"
#define FB_VAR_SNAPSHOT_UPDATE_STATUS "snapshot-update-status"
#define FB_VAR_CPU_ABI "cpu-abi"
+#define FB_VAR_SYSTEM_FINGERPRINT "system-fingerprint"
+#define FB_VAR_VENDOR_FINGERPRINT "vendor-fingerprint"
+#define FB_VAR_DYNAMIC_PARTITION "dynamic-partition"
+#define FB_VAR_FIRST_API_LEVEL "first-api-level"
+#define FB_VAR_SECURITY_PATCH_LEVEL "security-patch-level"
+#define FB_VAR_TREBLE_ENABLED "treble-enabled"
diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index b7263d9..2c9dec9 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -106,6 +106,8 @@
{FB_VAR_VERSION, {GetVersion, nullptr}},
{FB_VAR_VERSION_BOOTLOADER, {GetBootloaderVersion, nullptr}},
{FB_VAR_VERSION_BASEBAND, {GetBasebandVersion, nullptr}},
+ {FB_VAR_VERSION_OS, {GetOsVersion, nullptr}},
+ {FB_VAR_VERSION_VNDK, {GetVndkVersion, nullptr}},
{FB_VAR_PRODUCT, {GetProduct, nullptr}},
{FB_VAR_SERIALNO, {GetSerial, nullptr}},
{FB_VAR_VARIANT, {GetVariant, nullptr}},
@@ -127,7 +129,13 @@
{FB_VAR_HW_REVISION, {GetHardwareRevision, nullptr}},
{FB_VAR_SUPER_PARTITION_NAME, {GetSuperPartitionName, nullptr}},
{FB_VAR_SNAPSHOT_UPDATE_STATUS, {GetSnapshotUpdateStatus, nullptr}},
- {FB_VAR_CPU_ABI, {GetCpuAbi, nullptr}}};
+ {FB_VAR_CPU_ABI, {GetCpuAbi, nullptr}},
+ {FB_VAR_SYSTEM_FINGERPRINT, {GetSystemFingerprint, nullptr}},
+ {FB_VAR_VENDOR_FINGERPRINT, {GetVendorFingerprint, nullptr}},
+ {FB_VAR_DYNAMIC_PARTITION, {GetDynamicPartition, nullptr}},
+ {FB_VAR_FIRST_API_LEVEL, {GetFirstApiLevel, nullptr}},
+ {FB_VAR_SECURITY_PATCH_LEVEL, {GetSecurityPatchLevel, nullptr}},
+ {FB_VAR_TREBLE_ENABLED, {GetTrebleEnabled, nullptr}}};
if (args.size() < 2) {
return device->WriteFail("Missing argument");
diff --git a/fastboot/device/variables.cpp b/fastboot/device/variables.cpp
index 10eac01..e7d8bc3 100644
--- a/fastboot/device/variables.cpp
+++ b/fastboot/device/variables.cpp
@@ -62,6 +62,18 @@
return true;
}
+bool GetOsVersion(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.build.version.release", "");
+ return true;
+}
+
+bool GetVndkVersion(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.vndk.version", "");
+ return true;
+}
+
bool GetProduct(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
std::string* message) {
*message = android::base::GetProperty("ro.product.device", "");
@@ -458,3 +470,42 @@
*message = android::base::GetProperty("ro.product.cpu.abi", "");
return true;
}
+
+bool GetSystemFingerprint(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.system.build.fingerprint", "");
+ if (message->empty()) {
+ *message = android::base::GetProperty("ro.build.fingerprint", "");
+ }
+ return true;
+}
+
+bool GetVendorFingerprint(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.vendor.build.fingerprint", "");
+ return true;
+}
+
+bool GetDynamicPartition(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.boot.dynamic_partitions", "");
+ return true;
+}
+
+bool GetFirstApiLevel(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.product.first_api_level", "");
+ return true;
+}
+
+bool GetSecurityPatchLevel(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.build.version.security_patch", "");
+ return true;
+}
+
+bool GetTrebleEnabled(FastbootDevice* /* device */, const std::vector<std::string>& /* args */,
+ std::string* message) {
+ *message = android::base::GetProperty("ro.treble.enabled", "");
+ return true;
+}
diff --git a/fastboot/device/variables.h b/fastboot/device/variables.h
index 90840d6..c11e472 100644
--- a/fastboot/device/variables.h
+++ b/fastboot/device/variables.h
@@ -26,6 +26,10 @@
std::string* message);
bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args,
std::string* message);
+bool GetOsVersion(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetVndkVersion(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
bool GetProduct(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
bool GetSerial(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
bool GetSecure(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
@@ -64,6 +68,18 @@
bool GetSnapshotUpdateStatus(FastbootDevice* device, const std::vector<std::string>& args,
std::string* message);
bool GetCpuAbi(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
+bool GetSystemFingerprint(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetVendorFingerprint(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetDynamicPartition(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetFirstApiLevel(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetSecurityPatchLevel(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
+bool GetTrebleEnabled(FastbootDevice* device, const std::vector<std::string>& args,
+ std::string* message);
// Helpers for getvar all.
std::vector<std::vector<std::string>> GetAllPartitionArgsWithSlot(FastbootDevice* device);
diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index ed82066..3463a68 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -86,6 +86,7 @@
#define ZRAM_BACK_DEV "/sys/block/zram0/backing_dev"
#define SYSFS_EXT4_VERITY "/sys/fs/ext4/features/verity"
+#define SYSFS_EXT4_CASEFOLD "/sys/fs/ext4/features/casefold"
// FIXME: this should be in system/extras
#define EXT4_FEATURE_COMPAT_STABLE_INODES 0x0800
@@ -123,6 +124,7 @@
FS_STAT_SET_RESERVED_BLOCKS_FAILED = 0x20000,
FS_STAT_ENABLE_ENCRYPTION_FAILED = 0x40000,
FS_STAT_ENABLE_VERITY_FAILED = 0x80000,
+ FS_STAT_ENABLE_CASEFOLD_FAILED = 0x100000,
};
static void log_fs_stat(const std::string& blk_device, int fs_stat) {
@@ -344,6 +346,7 @@
const struct ext4_super_block* sb, int* fs_stat) {
bool has_quota = (sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_QUOTA)) != 0;
bool want_quota = entry.fs_mgr_flags.quota;
+ bool want_projid = android::base::GetBoolProperty("ro.emulated_storage.projid", false);
if (has_quota == want_quota) {
return;
@@ -360,12 +363,16 @@
if (want_quota) {
LINFO << "Enabling quotas on " << blk_device;
argv[1] = "-Oquota";
- argv[2] = "-Qusrquota,grpquota";
+ // Once usr/grp unneeded, make just prjquota to save overhead
+ if (want_projid)
+ argv[2] = "-Qusrquota,grpquota,prjquota";
+ else
+ argv[2] = "-Qusrquota,grpquota";
*fs_stat |= FS_STAT_QUOTA_ENABLED;
} else {
LINFO << "Disabling quotas on " << blk_device;
argv[1] = "-O^quota";
- argv[2] = "-Q^usrquota,^grpquota";
+ argv[2] = "-Q^usrquota,^grpquota,^prjquota";
}
if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
@@ -498,6 +505,42 @@
}
}
+// Enable casefold if needed.
+static void tune_casefold(const std::string& blk_device, const struct ext4_super_block* sb,
+ int* fs_stat) {
+ bool has_casefold =
+ (sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_CASEFOLD)) != 0;
+ bool wants_casefold = android::base::GetBoolProperty("ro.emulated_storage.casefold", false);
+
+ if (!wants_casefold || has_casefold) return;
+
+ std::string casefold_support;
+ if (!android::base::ReadFileToString(SYSFS_EXT4_CASEFOLD, &casefold_support)) {
+ LERROR << "Failed to open " << SYSFS_EXT4_CASEFOLD;
+ return;
+ }
+
+ if (!(android::base::Trim(casefold_support) == "supported")) {
+ LERROR << "Current ext4 casefolding not supported by kernel";
+ return;
+ }
+
+ if (!tune2fs_available()) {
+ LERROR << "Unable to enable ext4 casefold on " << blk_device
+ << " because " TUNE2FS_BIN " is missing";
+ return;
+ }
+
+ LINFO << "Enabling ext4 casefold on " << blk_device;
+
+ const char* argv[] = {TUNE2FS_BIN, "-O", "casefold", "-E", "encoding=utf8", blk_device.c_str()};
+ if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
+ LERROR << "Failed to run " TUNE2FS_BIN " to enable "
+ << "ext4 casefold on " << blk_device;
+ *fs_stat |= FS_STAT_ENABLE_CASEFOLD_FAILED;
+ }
+}
+
// Read the primary superblock from an f2fs filesystem. On failure return
// false. If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC.
#define F2FS_BLKSIZE 4096
@@ -595,6 +638,7 @@
tune_reserved_size(blk_device, entry, &sb, &fs_stat);
tune_encrypt(blk_device, entry, &sb, &fs_stat);
tune_verity(blk_device, entry, &sb, &fs_stat);
+ tune_casefold(blk_device, &sb, &fs_stat);
}
}
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 912087c..88d6b8d 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -828,7 +828,8 @@
cancelled = true;
break;
default:
- LOG(ERROR) << "Unknown merge status: " << static_cast<uint32_t>(snapshot_state);
+ LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": "
+ << "\"" << snapshot_state << "\"";
failed = true;
break;
}
@@ -1218,7 +1219,8 @@
if (!UnmapPartitionWithSnapshot(lock, name) || !DeleteSnapshot(lock, name)) {
// Remember whether or not we were able to unmap the cow image.
auto cow_image_device = GetCowImageDeviceName(name);
- has_mapped_cow_images |= images_->IsImageMapped(cow_image_device);
+ has_mapped_cow_images |=
+ (EnsureImageManager() && images_->IsImageMapped(cow_image_device));
ok = false;
}
@@ -1706,7 +1708,7 @@
} else if (contents == "merge-failed") {
return UpdateState::MergeFailed;
} else {
- LOG(ERROR) << "Unknown merge state in update state file";
+ LOG(ERROR) << "Unknown merge state in update state file: \"" << contents << "\"";
return UpdateState::None;
}
}
@@ -1728,7 +1730,7 @@
case UpdateState::MergeFailed:
return os << "merge-failed";
default:
- LOG(ERROR) << "Unknown update state";
+ LOG(ERROR) << "Unknown update state: " << static_cast<uint32_t>(state);
return os;
}
}
diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index bdf4aac..7caf468 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -126,6 +126,26 @@
return *ret;
}
+BatteryCapacityLevel getBatteryCapacityLevel(const char* capacityLevel) {
+ static SysfsStringEnumMap<BatteryCapacityLevel> batteryCapacityLevelMap[] = {
+ {"Unknown", BatteryCapacityLevel::UNKNOWN},
+ {"Critical", BatteryCapacityLevel::CRITICAL},
+ {"Low", BatteryCapacityLevel::LOW},
+ {"Normal", BatteryCapacityLevel::NORMAL},
+ {"High", BatteryCapacityLevel::HIGH},
+ {"Full", BatteryCapacityLevel::FULL},
+ {NULL, BatteryCapacityLevel::UNKNOWN},
+ };
+
+ auto ret = mapSysfsString(capacityLevel, batteryCapacityLevelMap);
+ if (!ret) {
+ KLOG_WARNING(LOG_TAG, "Unknown battery capacity level '%s'\n", capacityLevel);
+ *ret = BatteryCapacityLevel::UNKNOWN;
+ }
+
+ return *ret;
+}
+
BatteryHealth getBatteryHealth(const char* status) {
static SysfsStringEnumMap<BatteryHealth> batteryHealthMap[] = {
{"Unknown", BatteryHealth::UNKNOWN},
@@ -241,9 +261,10 @@
mHealthInfo->legacy.batteryCurrentAverage =
getIntField(mHealthdConfig->batteryCurrentAvgPath);
- // TODO(b/142260281): Retrieve these values correctly.
- mHealthInfo->batteryCapacityLevel = BatteryCapacityLevel::UNKNOWN;
- mHealthInfo->batteryChargeTimeToFullNowSeconds = 0;
+ if (!mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+ mHealthInfo->batteryChargeTimeToFullNowSeconds =
+ getIntField(mHealthdConfig->batteryChargeTimeToFullNowPath);
+
mHealthInfo->batteryFullCapacityUah = props.batteryFullCharge;
props.batteryTemperature = mBatteryFixedTemperature ?
@@ -252,6 +273,9 @@
std::string buf;
+ if (readFromFile(mHealthdConfig->batteryCapacityLevelPath, &buf) > 0)
+ mHealthInfo->batteryCapacityLevel = getBatteryCapacityLevel(buf.c_str());
+
if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0)
props.batteryStatus = getBatteryStatus(buf.c_str());
@@ -585,6 +609,19 @@
mHealthdConfig->batteryCycleCountPath = path;
}
+ if (mHealthdConfig->batteryCapacityLevelPath.isEmpty()) {
+ path.clear();
+ path.appendFormat("%s/%s/capacity_level", POWER_SUPPLY_SYSFS_PATH, name);
+ if (access(path, R_OK) == 0) mHealthdConfig->batteryCapacityLevelPath = path;
+ }
+
+ if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty()) {
+ path.clear();
+ path.appendFormat("%s/%s/time_to_full_now", POWER_SUPPLY_SYSFS_PATH, name);
+ if (access(path, R_OK) == 0)
+ mHealthdConfig->batteryChargeTimeToFullNowPath = path;
+ }
+
if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
path.clear();
path.appendFormat("%s/%s/current_avg",
@@ -653,6 +690,10 @@
KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n");
if (mHealthdConfig->batteryCycleCountPath.isEmpty())
KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n");
+ if (mHealthdConfig->batteryCapacityLevelPath.isEmpty())
+ KLOG_WARNING(LOG_TAG, "batteryCapacityLevelPath not found\n");
+ if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+ KLOG_WARNING(LOG_TAG, "batteryChargeTimeToFullNowPath. not found\n");
}
if (property_get("ro.boot.fake_battery", pval, NULL) > 0
diff --git a/healthd/include/healthd/healthd.h b/healthd/include/healthd/healthd.h
index a900071..8ffb114 100644
--- a/healthd/include/healthd/healthd.h
+++ b/healthd/include/healthd/healthd.h
@@ -69,6 +69,8 @@
android::String8 batteryChargeCounterPath;
android::String8 batteryFullChargePath;
android::String8 batteryCycleCountPath;
+ android::String8 batteryCapacityLevelPath;
+ android::String8 batteryChargeTimeToFullNowPath;
int (*energyCounter)(int64_t *);
int boot_min_cap;
diff --git a/liblog/include/android/log.h b/liblog/include/android/log.h
index 00aafaa..c84ddf7 100644
--- a/liblog/include/android/log.h
+++ b/liblog/include/android/log.h
@@ -276,6 +276,13 @@
*/
int __android_log_get_minimum_priority();
+/**
+ * Sets the default tag if no tag is provided when writing a log message. Defaults to
+ * getprogname(). This truncates tag to the maximum log message size, though appropriate tags
+ * should be much smaller.
+ */
+void __android_log_set_default_tag(const char* tag);
+
#ifdef __cplusplus
}
#endif
diff --git a/liblog/liblog.map.txt b/liblog/liblog.map.txt
index 62b9805..198cdae 100644
--- a/liblog/liblog.map.txt
+++ b/liblog/liblog.map.txt
@@ -73,6 +73,7 @@
__android_log_logd_logger;
__android_log_security_bswrite; # apex
__android_log_set_aborter;
+ __android_log_set_default_tag;
__android_log_set_logger;
__android_log_set_minimum_priority;
__android_log_stderr_logger;
diff --git a/liblog/logger_write.cpp b/liblog/logger_write.cpp
index 1783854..e86d9ec 100644
--- a/liblog/logger_write.cpp
+++ b/liblog/logger_write.cpp
@@ -16,6 +16,7 @@
#include <errno.h>
#include <inttypes.h>
+#include <libgen.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
@@ -31,6 +32,7 @@
#include <private/android_logger.h>
#include "android/log.h"
+#include "log/log_read.h"
#include "logger.h"
#include "rwlock.h"
#include "uio.h"
@@ -106,6 +108,45 @@
#endif
}
+#if defined(__GLIBC__) || defined(_WIN32)
+static const char* getprogname() {
+#if defined(__GLIBC__)
+ return program_invocation_short_name;
+#elif defined(_WIN32)
+ static bool first = true;
+ static char progname[MAX_PATH] = {};
+
+ if (first) {
+ char path[PATH_MAX + 1];
+ DWORD result = GetModuleFileName(nullptr, path, sizeof(path) - 1);
+ if (result == 0 || result == sizeof(path) - 1) return "";
+ path[PATH_MAX - 1] = 0;
+
+ char* path_basename = basename(path);
+
+ snprintf(progname, sizeof(progname), "%s", path_basename);
+ first = false;
+ }
+
+ return progname;
+#endif
+}
+#endif
+
+// It's possible for logging to happen during static initialization before our globals are
+// initialized, so we place this std::string in a function such that it is initialized on the first
+// call.
+static std::string& GetDefaultTag() {
+ static std::string default_tag = getprogname();
+ return default_tag;
+}
+static RwLock default_tag_lock;
+
+void __android_log_set_default_tag(const char* tag) {
+ auto lock = std::unique_lock{default_tag_lock};
+ GetDefaultTag().assign(tag, 0, LOGGER_ENTRY_MAX_PAYLOAD);
+}
+
static int minimum_log_priority = ANDROID_LOG_DEFAULT;
int __android_log_set_minimum_priority(int priority) {
int old_minimum_log_priority = minimum_log_priority;
@@ -270,7 +311,11 @@
}
void __android_log_write_logger_data(__android_logger_data* logger_data, const char* msg) {
- if (logger_data->tag == nullptr) logger_data->tag = "";
+ auto tag_lock = std::shared_lock{default_tag_lock, std::defer_lock};
+ if (logger_data->tag == nullptr) {
+ tag_lock.lock();
+ logger_data->tag = GetDefaultTag().c_str();
+ }
#if __BIONIC__
if (logger_data->priority == ANDROID_LOG_FATAL) {
diff --git a/liblog/tests/Android.bp b/liblog/tests/Android.bp
index 3288954..b3364f9 100644
--- a/liblog/tests/Android.bp
+++ b/liblog/tests/Android.bp
@@ -54,6 +54,7 @@
],
srcs: [
"libc_test.cpp",
+ "liblog_default_tag.cpp",
"liblog_global_state.cpp",
"liblog_test.cpp",
"log_id_test.cpp",
diff --git a/liblog/tests/liblog_default_tag.cpp b/liblog/tests/liblog_default_tag.cpp
new file mode 100644
index 0000000..a5baa9f
--- /dev/null
+++ b/liblog/tests/liblog_default_tag.cpp
@@ -0,0 +1,99 @@
+/*
+ * 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.
+ */
+
+// LOG_TAG must be unset for android-base's logging to use a default tag.
+#undef LOG_TAG
+
+#include <stdlib.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android/log.h>
+
+#include <gtest/gtest.h>
+
+TEST(liblog_default_tag, no_default_tag_libbase_write_first) {
+ using namespace android::base;
+ bool message_seen = false;
+ std::string expected_tag = "";
+ SetLogger([&](LogId, LogSeverity, const char* tag, const char*, unsigned int, const char*) {
+ message_seen = true;
+ EXPECT_EQ(expected_tag, tag);
+ });
+
+ expected_tag = getprogname();
+ LOG(WARNING) << "message";
+ EXPECT_TRUE(message_seen);
+ message_seen = false;
+
+ __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_WARN, nullptr, "message");
+ EXPECT_TRUE(message_seen);
+}
+
+TEST(liblog_default_tag, no_default_tag_liblog_write_first) {
+ using namespace android::base;
+ bool message_seen = false;
+ std::string expected_tag = "";
+ SetLogger([&](LogId, LogSeverity, const char* tag, const char*, unsigned int, const char*) {
+ message_seen = true;
+ EXPECT_EQ(expected_tag, tag);
+ });
+
+ expected_tag = getprogname();
+ __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_WARN, nullptr, "message");
+ EXPECT_TRUE(message_seen);
+ message_seen = false;
+
+ LOG(WARNING) << "message";
+ EXPECT_TRUE(message_seen);
+}
+
+TEST(liblog_default_tag, libbase_sets_default_tag) {
+ using namespace android::base;
+ bool message_seen = false;
+ std::string expected_tag = "libbase_test_tag";
+ SetLogger([&](LogId, LogSeverity, const char* tag, const char*, unsigned int, const char*) {
+ message_seen = true;
+ EXPECT_EQ(expected_tag, tag);
+ });
+ SetDefaultTag(expected_tag);
+
+ __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_WARN, nullptr, "message");
+ EXPECT_TRUE(message_seen);
+ message_seen = false;
+
+ LOG(WARNING) << "message";
+ EXPECT_TRUE(message_seen);
+}
+
+TEST(liblog_default_tag, liblog_sets_default_tag) {
+ using namespace android::base;
+ bool message_seen = false;
+ std::string expected_tag = "liblog_test_tag";
+ SetLogger([&](LogId, LogSeverity, const char* tag, const char*, unsigned int, const char*) {
+ message_seen = true;
+ EXPECT_EQ(expected_tag, tag);
+ });
+ __android_log_set_default_tag(expected_tag.c_str());
+
+ __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_WARN, nullptr, "message");
+ EXPECT_TRUE(message_seen);
+ message_seen = false;
+
+ LOG(WARNING) << "message";
+ EXPECT_TRUE(message_seen);
+}
\ No newline at end of file
diff --git a/libstats/socket/Android.bp b/libstats/socket/Android.bp
index 3b6efbb..9fd9fbc 100644
--- a/libstats/socket/Android.bp
+++ b/libstats/socket/Android.bp
@@ -75,3 +75,22 @@
"libgtest_prod",
],
}
+
+cc_test {
+ name: "libstatssocket_test",
+ srcs: ["tests/stats_event_test.cpp"],
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ static_libs: [
+ "libgmock",
+ "libstatssocket",
+ ],
+ shared_libs: [
+ "libcutils",
+ "liblog",
+ "libutils",
+ ],
+ test_suites: ["device_tests"],
+}
diff --git a/libstats/socket/tests/stats_event_test.cpp b/libstats/socket/tests/stats_event_test.cpp
new file mode 100644
index 0000000..cf0592c
--- /dev/null
+++ b/libstats/socket/tests/stats_event_test.cpp
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stats_event.h"
+#include <gtest/gtest.h>
+#include <utils/SystemClock.h>
+
+using std::string;
+using std::vector;
+
+// Side-effect: this function moves the start of the buffer past the read value
+template <class T>
+T readNext(uint8_t** buffer) {
+ T value = *(T*)(*buffer);
+ *buffer += sizeof(T);
+ return value;
+}
+
+void checkTypeHeader(uint8_t** buffer, uint8_t typeId, uint8_t numAnnotations = 0) {
+ uint8_t typeHeader = (numAnnotations << 4) | typeId;
+ EXPECT_EQ(readNext<uint8_t>(buffer), typeHeader);
+}
+
+template <class T>
+void checkScalar(uint8_t** buffer, T expectedValue) {
+ EXPECT_EQ(readNext<T>(buffer), expectedValue);
+}
+
+void checkString(uint8_t** buffer, const string& expectedString) {
+ uint32_t size = readNext<uint32_t>(buffer);
+ string parsedString((char*)(*buffer), size);
+ EXPECT_EQ(parsedString, expectedString);
+ *buffer += size; // move buffer past string we just read
+}
+
+void checkByteArray(uint8_t** buffer, const vector<uint8_t>& expectedByteArray) {
+ uint32_t size = readNext<uint32_t>(buffer);
+ vector<uint8_t> parsedByteArray(*buffer, *buffer + size);
+ EXPECT_EQ(parsedByteArray, expectedByteArray);
+ *buffer += size; // move buffer past byte array we just read
+}
+
+template <class T>
+void checkAnnotation(uint8_t** buffer, uint8_t annotationId, uint8_t typeId, T annotationValue) {
+ EXPECT_EQ(readNext<uint8_t>(buffer), annotationId);
+ EXPECT_EQ(readNext<uint8_t>(buffer), typeId);
+ checkScalar<T>(buffer, annotationValue);
+}
+
+void checkMetadata(uint8_t** buffer, uint8_t numElements, int64_t startTime, int64_t endTime,
+ uint32_t atomId) {
+ // All events start with OBJECT_TYPE id.
+ checkTypeHeader(buffer, OBJECT_TYPE);
+
+ // We increment by 2 because the number of elements listed in the
+ // serialization accounts for the timestamp and atom id as well.
+ checkScalar(buffer, static_cast<uint8_t>(numElements + 2));
+
+ // Check timestamp
+ checkTypeHeader(buffer, INT64_TYPE);
+ int64_t timestamp = readNext<int64_t>(buffer);
+ EXPECT_GE(timestamp, startTime);
+ EXPECT_LE(timestamp, endTime);
+
+ // Check atom id
+ checkTypeHeader(buffer, INT32_TYPE);
+ checkScalar(buffer, atomId);
+}
+
+TEST(StatsEventTest, TestScalars) {
+ uint32_t atomId = 100;
+ int32_t int32Value = -5;
+ int64_t int64Value = -2 * android::elapsedRealtimeNano();
+ float floatValue = 2.0;
+ bool boolValue = false;
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, atomId);
+ stats_event_write_int32(event, int32Value);
+ stats_event_write_int64(event, int64Value);
+ stats_event_write_float(event, floatValue);
+ stats_event_write_bool(event, boolValue);
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/4, startTime, endTime, atomId);
+
+ // check int32 element
+ checkTypeHeader(&buffer, INT32_TYPE);
+ checkScalar(&buffer, int32Value);
+
+ // check int64 element
+ checkTypeHeader(&buffer, INT64_TYPE);
+ checkScalar(&buffer, int64Value);
+
+ // check float element
+ checkTypeHeader(&buffer, FLOAT_TYPE);
+ checkScalar(&buffer, floatValue);
+
+ // check bool element
+ checkTypeHeader(&buffer, BOOL_TYPE);
+ checkScalar(&buffer, boolValue);
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestStrings) {
+ uint32_t atomId = 100;
+ string str = "test_string";
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, atomId);
+ stats_event_write_string8(event, str.c_str());
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/1, startTime, endTime, atomId);
+
+ checkTypeHeader(&buffer, STRING_TYPE);
+ checkString(&buffer, str);
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestByteArrays) {
+ uint32_t atomId = 100;
+ vector<uint8_t> message = {'b', 'y', 't', '\0', 'e', 's'};
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, atomId);
+ stats_event_write_byte_array(event, message.data(), message.size());
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/1, startTime, endTime, atomId);
+
+ checkTypeHeader(&buffer, BYTE_ARRAY_TYPE);
+ checkByteArray(&buffer, message);
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestAttributionChains) {
+ uint32_t atomId = 100;
+
+ uint8_t numNodes = 50;
+ uint32_t uids[numNodes];
+ vector<string> tags(numNodes); // storage that cTag elements point to
+ const char* cTags[numNodes];
+ for (int i = 0; i < (int)numNodes; i++) {
+ uids[i] = i;
+ tags.push_back("test" + std::to_string(i));
+ cTags[i] = tags[i].c_str();
+ }
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, atomId);
+ stats_event_write_attribution_chain(event, uids, cTags, numNodes);
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/1, startTime, endTime, atomId);
+
+ checkTypeHeader(&buffer, ATTRIBUTION_CHAIN_TYPE);
+ checkScalar(&buffer, numNodes);
+ for (int i = 0; i < numNodes; i++) {
+ checkScalar(&buffer, uids[i]);
+ checkString(&buffer, tags[i]);
+ }
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestKeyValuePairs) {
+ uint32_t atomId = 100;
+
+ uint8_t numPairs = 4;
+ struct key_value_pair pairs[numPairs];
+ pairs[0] = {.key = 0, .valueType = INT32_TYPE, .int32Value = -1};
+ pairs[1] = {.key = 1, .valueType = INT64_TYPE, .int64Value = 0x123456789};
+ pairs[2] = {.key = 2, .valueType = FLOAT_TYPE, .floatValue = 5.5};
+ string str = "test_key_value_pair_string";
+ pairs[3] = {.key = 3, .valueType = STRING_TYPE, .stringValue = str.c_str()};
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, atomId);
+ stats_event_write_key_value_pairs(event, pairs, numPairs);
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/1, startTime, endTime, atomId);
+
+ checkTypeHeader(&buffer, KEY_VALUE_PAIRS_TYPE);
+ checkScalar(&buffer, numPairs);
+
+ // first pair
+ checkScalar(&buffer, pairs[0].key);
+ checkTypeHeader(&buffer, pairs[0].valueType);
+ checkScalar(&buffer, pairs[0].int32Value);
+
+ // second pair
+ checkScalar(&buffer, pairs[1].key);
+ checkTypeHeader(&buffer, pairs[1].valueType);
+ checkScalar(&buffer, pairs[1].int64Value);
+
+ // third pair
+ checkScalar(&buffer, pairs[2].key);
+ checkTypeHeader(&buffer, pairs[2].valueType);
+ checkScalar(&buffer, pairs[2].floatValue);
+
+ // fourth pair
+ checkScalar(&buffer, pairs[3].key);
+ checkTypeHeader(&buffer, pairs[3].valueType);
+ checkString(&buffer, str);
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestAnnotations) {
+ uint32_t atomId = 100;
+
+ // first element information
+ bool boolValue = false;
+ uint8_t boolAnnotation1Id = 1;
+ uint8_t boolAnnotation2Id = 2;
+ bool boolAnnotation1Value = true;
+ int32_t boolAnnotation2Value = 3;
+
+ // second element information
+ float floatValue = -5.0;
+ uint8_t floatAnnotation1Id = 3;
+ uint8_t floatAnnotation2Id = 4;
+ int32_t floatAnnotation1Value = 8;
+ bool floatAnnotation2Value = false;
+
+ int64_t startTime = android::elapsedRealtimeNano();
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, 100);
+ stats_event_write_bool(event, boolValue);
+ stats_event_add_bool_annotation(event, boolAnnotation1Id, boolAnnotation1Value);
+ stats_event_add_int32_annotation(event, boolAnnotation2Id, boolAnnotation2Value);
+ stats_event_write_float(event, floatValue);
+ stats_event_add_int32_annotation(event, floatAnnotation1Id, floatAnnotation1Value);
+ stats_event_add_bool_annotation(event, floatAnnotation2Id, floatAnnotation2Value);
+ stats_event_build(event);
+ int64_t endTime = android::elapsedRealtimeNano();
+
+ size_t bufferSize;
+ uint8_t* buffer = stats_event_get_buffer(event, &bufferSize);
+ uint8_t* bufferEnd = buffer + bufferSize;
+
+ checkMetadata(&buffer, /*numElements=*/2, startTime, endTime, atomId);
+
+ // check first element
+ checkTypeHeader(&buffer, BOOL_TYPE, /*numAnnotations=*/2);
+ checkScalar(&buffer, boolValue);
+ checkAnnotation(&buffer, boolAnnotation1Id, BOOL_TYPE, boolAnnotation1Value);
+ checkAnnotation(&buffer, boolAnnotation2Id, INT32_TYPE, boolAnnotation2Value);
+
+ // check second element
+ checkTypeHeader(&buffer, FLOAT_TYPE, /*numAnnotations=*/2);
+ checkScalar(&buffer, floatValue);
+ checkAnnotation(&buffer, floatAnnotation1Id, INT32_TYPE, floatAnnotation1Value);
+ checkAnnotation(&buffer, floatAnnotation2Id, BOOL_TYPE, floatAnnotation2Value);
+
+ EXPECT_EQ(buffer, bufferEnd); // ensure that we have read the entire buffer
+ EXPECT_EQ(stats_event_get_errors(event), 0);
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestNoAtomIdError) {
+ struct stats_event* event = stats_event_obtain();
+ // Don't set the atom id in order to trigger the error.
+ stats_event_build(event);
+
+ uint32_t errors = stats_event_get_errors(event);
+ EXPECT_NE(errors | ERROR_NO_ATOM_ID, 0);
+
+ stats_event_release(event);
+}
+
+TEST(StatsEventTest, TestOverflowError) {
+ struct stats_event* event = stats_event_obtain();
+ stats_event_set_atom_id(event, 100);
+ // Add 1000 int32s to the event. Each int32 takes 5 bytes so this will
+ // overflow the 4068 byte buffer.
+ for (int i = 0; i < 1000; i++) {
+ stats_event_write_int32(event, 0);
+ }
+ stats_event_build(event);
+
+ uint32_t errors = stats_event_get_errors(event);
+ EXPECT_NE(errors | ERROR_OVERFLOW, 0);
+
+ stats_event_release(event);
+}
diff --git a/libunwindstack/Android.bp b/libunwindstack/Android.bp
index 9cd3d65..3695f72 100644
--- a/libunwindstack/Android.bp
+++ b/libunwindstack/Android.bp
@@ -240,6 +240,7 @@
"tests/files/offline/debug_frame_load_bias_arm/*",
"tests/files/offline/eh_frame_bias_x86/*",
"tests/files/offline/eh_frame_hdr_begin_x86_64/*",
+ "tests/files/offline/empty_arm64/*",
"tests/files/offline/invalid_elf_offset_arm/*",
"tests/files/offline/jit_debug_arm/*",
"tests/files/offline/jit_debug_x86/*",
diff --git a/libunwindstack/MapInfo.cpp b/libunwindstack/MapInfo.cpp
index f2dad84..31f3144 100644
--- a/libunwindstack/MapInfo.cpp
+++ b/libunwindstack/MapInfo.cpp
@@ -37,12 +37,12 @@
bool MapInfo::InitFileMemoryFromPreviousReadOnlyMap(MemoryFileAtOffset* memory) {
// One last attempt, see if the previous map is read-only with the
// same name and stretches across this map.
- if (prev_map == nullptr || prev_map->flags != PROT_READ) {
+ if (prev_real_map == nullptr || prev_real_map->flags != PROT_READ) {
return false;
}
- uint64_t map_size = end - prev_map->end;
- if (!memory->Init(name, prev_map->offset, map_size)) {
+ uint64_t map_size = end - prev_real_map->end;
+ if (!memory->Init(name, prev_real_map->offset, map_size)) {
return false;
}
@@ -51,12 +51,12 @@
return false;
}
- if (!memory->Init(name, prev_map->offset, max_size)) {
+ if (!memory->Init(name, prev_real_map->offset, max_size)) {
return false;
}
- elf_offset = offset - prev_map->offset;
- elf_start_offset = prev_map->offset;
+ elf_offset = offset - prev_real_map->offset;
+ elf_start_offset = prev_real_map->offset;
return true;
}
@@ -112,8 +112,8 @@
// Need to check how to set the elf start offset. If this map is not
// the r-x map of a r-- map, then use the real offset value. Otherwise,
// use 0.
- if (prev_map == nullptr || prev_map->offset != 0 || prev_map->flags != PROT_READ ||
- prev_map->name != name) {
+ if (prev_real_map == nullptr || prev_real_map->offset != 0 ||
+ prev_real_map->flags != PROT_READ || prev_real_map->name != name) {
elf_start_offset = offset;
}
return memory.release();
@@ -172,20 +172,20 @@
// doesn't guarantee that this invariant will always be true. However,
// if that changes, there is likely something else that will change and
// break something.
- if (offset == 0 || name.empty() || prev_map == nullptr || prev_map->name != name ||
- prev_map->offset >= offset) {
+ if (offset == 0 || name.empty() || prev_real_map == nullptr || prev_real_map->name != name ||
+ prev_real_map->offset >= offset) {
return nullptr;
}
// Make sure that relative pc values are corrected properly.
- elf_offset = offset - prev_map->offset;
+ elf_offset = offset - prev_real_map->offset;
// Use this as the elf start offset, otherwise, you always get offsets into
// the r-x section, which is not quite the right information.
- elf_start_offset = prev_map->offset;
+ elf_start_offset = prev_real_map->offset;
MemoryRanges* ranges = new MemoryRanges;
- ranges->Insert(
- new MemoryRange(process_memory, prev_map->start, prev_map->end - prev_map->start, 0));
+ ranges->Insert(new MemoryRange(process_memory, prev_real_map->start,
+ prev_real_map->end - prev_real_map->start, 0));
ranges->Insert(new MemoryRange(process_memory, start, end - start, elf_offset));
memory_backed_elf = true;
@@ -236,15 +236,15 @@
if (!elf->valid()) {
elf_start_offset = offset;
- } else if (prev_map != nullptr && elf_start_offset != offset &&
- prev_map->offset == elf_start_offset && prev_map->name == name) {
+ } else if (prev_real_map != nullptr && elf_start_offset != offset &&
+ prev_real_map->offset == elf_start_offset && prev_real_map->name == name) {
// If there is a read-only map then a read-execute map that represents the
// same elf object, make sure the previous map is using the same elf
// object if it hasn't already been set.
- std::lock_guard<std::mutex> guard(prev_map->mutex_);
- if (prev_map->elf.get() == nullptr) {
- prev_map->elf = elf;
- prev_map->memory_backed_elf = memory_backed_elf;
+ std::lock_guard<std::mutex> guard(prev_real_map->mutex_);
+ if (prev_real_map->elf.get() == nullptr) {
+ prev_real_map->elf = elf;
+ prev_real_map->memory_backed_elf = memory_backed_elf;
}
}
return elf.get();
diff --git a/libunwindstack/Maps.cpp b/libunwindstack/Maps.cpp
index 0ab68db..8f49ad9 100644
--- a/libunwindstack/Maps.cpp
+++ b/libunwindstack/Maps.cpp
@@ -60,6 +60,8 @@
}
bool Maps::Parse() {
+ MapInfo* prev_map = nullptr;
+ MapInfo* prev_real_map = nullptr;
return android::procinfo::ReadMapFile(
GetMapsFile(),
[&](uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t, const char* name) {
@@ -67,17 +69,24 @@
if (strncmp(name, "/dev/", 5) == 0 && strncmp(name + 5, "ashmem/", 7) != 0) {
flags |= unwindstack::MAPS_FLAGS_DEVICE_MAP;
}
- maps_.emplace_back(
- new MapInfo(maps_.empty() ? nullptr : maps_.back().get(), start, end, pgoff,
- flags, name));
+ maps_.emplace_back(new MapInfo(prev_map, prev_real_map, start, end, pgoff, flags, name));
+ prev_map = maps_.back().get();
+ if (!prev_map->IsBlank()) {
+ prev_real_map = prev_map;
+ }
});
}
void Maps::Add(uint64_t start, uint64_t end, uint64_t offset, uint64_t flags,
const std::string& name, uint64_t load_bias) {
+ MapInfo* prev_map = maps_.empty() ? nullptr : maps_.back().get();
+ MapInfo* prev_real_map = prev_map;
+ while (prev_real_map != nullptr && prev_real_map->IsBlank()) {
+ prev_real_map = prev_real_map->prev_map;
+ }
+
auto map_info =
- std::make_unique<MapInfo>(maps_.empty() ? nullptr : maps_.back().get(), start, end, offset,
- flags, name);
+ std::make_unique<MapInfo>(prev_map, prev_real_map, start, end, offset, flags, name);
map_info->load_bias = load_bias;
maps_.emplace_back(std::move(map_info));
}
@@ -89,14 +98,21 @@
// Set the prev_map values on the info objects.
MapInfo* prev_map = nullptr;
+ MapInfo* prev_real_map = nullptr;
for (const auto& map_info : maps_) {
map_info->prev_map = prev_map;
+ map_info->prev_real_map = prev_real_map;
prev_map = map_info.get();
+ if (!prev_map->IsBlank()) {
+ prev_real_map = prev_map;
+ }
}
}
bool BufferMaps::Parse() {
std::string content(buffer_);
+ MapInfo* prev_map = nullptr;
+ MapInfo* prev_real_map = nullptr;
return android::procinfo::ReadMapFileContent(
&content[0],
[&](uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t, const char* name) {
@@ -104,9 +120,11 @@
if (strncmp(name, "/dev/", 5) == 0 && strncmp(name + 5, "ashmem/", 7) != 0) {
flags |= unwindstack::MAPS_FLAGS_DEVICE_MAP;
}
- maps_.emplace_back(
- new MapInfo(maps_.empty() ? nullptr : maps_.back().get(), start, end, pgoff,
- flags, name));
+ maps_.emplace_back(new MapInfo(prev_map, prev_real_map, start, end, pgoff, flags, name));
+ prev_map = maps_.back().get();
+ if (!prev_map->IsBlank()) {
+ prev_real_map = prev_map;
+ }
});
}
diff --git a/libunwindstack/include/unwindstack/MapInfo.h b/libunwindstack/include/unwindstack/MapInfo.h
index 8f0c516..052e79f 100644
--- a/libunwindstack/include/unwindstack/MapInfo.h
+++ b/libunwindstack/include/unwindstack/MapInfo.h
@@ -31,24 +31,26 @@
class MemoryFileAtOffset;
struct MapInfo {
- MapInfo(MapInfo* map_info, uint64_t start, uint64_t end, uint64_t offset, uint64_t flags,
- const char* name)
+ MapInfo(MapInfo* prev_map, MapInfo* prev_real_map, uint64_t start, uint64_t end, uint64_t offset,
+ uint64_t flags, const char* name)
: start(start),
end(end),
offset(offset),
flags(flags),
name(name),
- prev_map(map_info),
+ prev_map(prev_map),
+ prev_real_map(prev_real_map),
load_bias(INT64_MAX),
build_id(0) {}
- MapInfo(MapInfo* map_info, uint64_t start, uint64_t end, uint64_t offset, uint64_t flags,
- const std::string& name)
+ MapInfo(MapInfo* prev_map, MapInfo* prev_real_map, uint64_t start, uint64_t end, uint64_t offset,
+ uint64_t flags, const std::string& name)
: start(start),
end(end),
offset(offset),
flags(flags),
name(name),
- prev_map(map_info),
+ prev_map(prev_map),
+ prev_real_map(prev_real_map),
load_bias(INT64_MAX),
build_id(0) {}
~MapInfo();
@@ -71,6 +73,14 @@
uint64_t elf_start_offset = 0;
MapInfo* prev_map = nullptr;
+ // This is the previous map that is not empty with a 0 offset. For
+ // example, this set of maps:
+ // 1000-2000 r--p 000000 00:00 0 libc.so
+ // 2000-3000 ---p 000000 00:00 0 libc.so
+ // 3000-4000 r-xp 003000 00:00 0 libc.so
+ // The last map's prev_map would point to the 2000-3000 map, while the
+ // prev_real_map would point to the 1000-2000 map.
+ MapInfo* prev_real_map = nullptr;
std::atomic_int64_t load_bias;
@@ -97,6 +107,8 @@
// Returns the printable version of the build id (hex dump of raw data).
std::string GetPrintableBuildID();
+ inline bool IsBlank() { return offset == 0 && flags == 0 && name.empty(); }
+
private:
MapInfo(const MapInfo&) = delete;
void operator=(const MapInfo&) = delete;
diff --git a/libunwindstack/tests/DexFileTest.cpp b/libunwindstack/tests/DexFileTest.cpp
index 0149a42..1b54da6 100644
--- a/libunwindstack/tests/DexFileTest.cpp
+++ b/libunwindstack/tests/DexFileTest.cpp
@@ -105,7 +105,7 @@
static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData)))));
MemoryFake memory;
- MapInfo info(nullptr, 0, 0x10000, 0, 0x5, tf.path);
+ MapInfo info(nullptr, nullptr, 0, 0x10000, 0, 0x5, tf.path);
EXPECT_TRUE(DexFile::Create(0x500, &memory, &info) != nullptr);
}
@@ -118,7 +118,7 @@
static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData)))));
MemoryFake memory;
- MapInfo info(nullptr, 0x100, 0x10000, 0, 0x5, tf.path);
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0, 0x5, tf.path);
EXPECT_TRUE(DexFile::Create(0x600, &memory, &info) != nullptr);
}
@@ -131,21 +131,21 @@
static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData)))));
MemoryFake memory;
- MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, tf.path);
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0x200, 0x5, tf.path);
EXPECT_TRUE(DexFile::Create(0x400, &memory, &info) != nullptr);
}
TEST(DexFileTest, create_using_memory_empty_file) {
MemoryFake memory;
memory.SetMemory(0x4000, kDexData, sizeof(kDexData));
- MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "");
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0x200, 0x5, "");
EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr);
}
TEST(DexFileTest, create_using_memory_file_does_not_exist) {
MemoryFake memory;
memory.SetMemory(0x4000, kDexData, sizeof(kDexData));
- MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "/does/not/exist");
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0x200, 0x5, "/does/not/exist");
EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr);
}
@@ -158,7 +158,7 @@
MemoryFake memory;
memory.SetMemory(0x4000, kDexData, sizeof(kDexData));
- MapInfo info(nullptr, 0x4000, 0x10000, 0x200, 0x5, "/does/not/exist");
+ MapInfo info(nullptr, nullptr, 0x4000, 0x10000, 0x200, 0x5, "/does/not/exist");
std::unique_ptr<DexFile> dex_file = DexFile::Create(0x4000, &memory, &info);
ASSERT_TRUE(dex_file != nullptr);
@@ -171,7 +171,7 @@
TEST(DexFileTest, get_method) {
MemoryFake memory;
memory.SetMemory(0x4000, kDexData, sizeof(kDexData));
- MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "");
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0x200, 0x5, "");
std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info));
ASSERT_TRUE(dex_file != nullptr);
@@ -189,7 +189,7 @@
TEST(DexFileTest, get_method_empty) {
MemoryFake memory;
memory.SetMemory(0x4000, kDexData, sizeof(kDexData));
- MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "");
+ MapInfo info(nullptr, nullptr, 0x100, 0x10000, 0x200, 0x5, "");
std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info));
ASSERT_TRUE(dex_file != nullptr);
diff --git a/libunwindstack/tests/ElfCacheTest.cpp b/libunwindstack/tests/ElfCacheTest.cpp
index 5735858..5f13546 100644
--- a/libunwindstack/tests/ElfCacheTest.cpp
+++ b/libunwindstack/tests/ElfCacheTest.cpp
@@ -78,8 +78,8 @@
uint64_t start = 0x1000;
uint64_t end = 0x20000;
- MapInfo info1(nullptr, start, end, 0, 0x5, tf.path);
- MapInfo info2(nullptr, start, end, 0, 0x5, tf.path);
+ MapInfo info1(nullptr, nullptr, start, end, 0, 0x5, tf.path);
+ MapInfo info2(nullptr, nullptr, start, end, 0, 0x5, tf.path);
Elf* elf1 = info1.GetElf(memory_, ARCH_ARM);
ASSERT_TRUE(elf1->valid());
@@ -119,17 +119,17 @@
uint64_t start = 0x1000;
uint64_t end = 0x20000;
// Will have an elf at offset 0 in file.
- MapInfo info0_1(nullptr, start, end, 0, 0x5, tf.path);
- MapInfo info0_2(nullptr, start, end, 0, 0x5, tf.path);
+ MapInfo info0_1(nullptr, nullptr, start, end, 0, 0x5, tf.path);
+ MapInfo info0_2(nullptr, nullptr, start, end, 0, 0x5, tf.path);
// Will have an elf at offset 0x100 in file.
- MapInfo info100_1(nullptr, start, end, 0x100, 0x5, tf.path);
- MapInfo info100_2(nullptr, start, end, 0x100, 0x5, tf.path);
+ MapInfo info100_1(nullptr, nullptr, start, end, 0x100, 0x5, tf.path);
+ MapInfo info100_2(nullptr, nullptr, start, end, 0x100, 0x5, tf.path);
// Will have an elf at offset 0x200 in file.
- MapInfo info200_1(nullptr, start, end, 0x200, 0x5, tf.path);
- MapInfo info200_2(nullptr, start, end, 0x200, 0x5, tf.path);
+ MapInfo info200_1(nullptr, nullptr, start, end, 0x200, 0x5, tf.path);
+ MapInfo info200_2(nullptr, nullptr, start, end, 0x200, 0x5, tf.path);
// Will have an elf at offset 0 in file.
- MapInfo info300_1(nullptr, start, end, 0x300, 0x5, tf.path);
- MapInfo info300_2(nullptr, start, end, 0x300, 0x5, tf.path);
+ MapInfo info300_1(nullptr, nullptr, start, end, 0x300, 0x5, tf.path);
+ MapInfo info300_2(nullptr, nullptr, start, end, 0x300, 0x5, tf.path);
Elf* elf0_1 = info0_1.GetElf(memory_, ARCH_ARM);
ASSERT_TRUE(elf0_1->valid());
@@ -216,10 +216,10 @@
uint64_t start = 0x1000;
uint64_t end = 0x20000;
// Multiple info sections at different offsets will have non-zero elf offsets.
- MapInfo info300_1(nullptr, start, end, 0x300, 0x5, tf.path);
- MapInfo info300_2(nullptr, start, end, 0x300, 0x5, tf.path);
- MapInfo info400_1(nullptr, start, end, 0x400, 0x5, tf.path);
- MapInfo info400_2(nullptr, start, end, 0x400, 0x5, tf.path);
+ MapInfo info300_1(nullptr, nullptr, start, end, 0x300, 0x5, tf.path);
+ MapInfo info300_2(nullptr, nullptr, start, end, 0x300, 0x5, tf.path);
+ MapInfo info400_1(nullptr, nullptr, start, end, 0x400, 0x5, tf.path);
+ MapInfo info400_2(nullptr, nullptr, start, end, 0x400, 0x5, tf.path);
Elf* elf300_1 = info300_1.GetElf(memory_, ARCH_ARM);
ASSERT_TRUE(elf300_1->valid());
diff --git a/libunwindstack/tests/ElfTest.cpp b/libunwindstack/tests/ElfTest.cpp
index 4866345..1f3ed81 100644
--- a/libunwindstack/tests/ElfTest.cpp
+++ b/libunwindstack/tests/ElfTest.cpp
@@ -275,7 +275,7 @@
elf.FakeSetInterface(interface);
elf.FakeSetValid(true);
- MapInfo map_info(nullptr, 0x1000, 0x2000, 0, 0, "");
+ MapInfo map_info(nullptr, nullptr, 0x1000, 0x2000, 0, 0, "");
ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, &map_info));
diff --git a/libunwindstack/tests/MapInfoCreateMemoryTest.cpp b/libunwindstack/tests/MapInfoCreateMemoryTest.cpp
index 6c1cfa2..6d8d58e 100644
--- a/libunwindstack/tests/MapInfoCreateMemoryTest.cpp
+++ b/libunwindstack/tests/MapInfoCreateMemoryTest.cpp
@@ -89,7 +89,7 @@
};
TEST_F(MapInfoCreateMemoryTest, end_le_start) {
- MapInfo info(nullptr, 0x100, 0x100, 0, 0, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x100, 0x100, 0, 0, elf_.path);
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() == nullptr);
@@ -108,7 +108,7 @@
// Verify that if the offset is non-zero but there is no elf at the offset,
// that the full file is used.
TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_full_file) {
- MapInfo info(nullptr, 0x100, 0x200, 0x100, 0, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x100, 0x200, 0x100, 0, elf_.path);
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() != nullptr);
@@ -129,8 +129,9 @@
// Now verify the elf start offset is set correctly based on the previous
// info.
- MapInfo prev_info(nullptr, 0, 0x100, 0x10, 0, "");
+ MapInfo prev_info(nullptr, nullptr, 0, 0x100, 0x10, 0, "");
info.prev_map = &prev_info;
+ info.prev_real_map = &prev_info;
// No preconditions met, change each one until it should set the elf start
// offset to zero.
@@ -177,7 +178,7 @@
// Verify that if the offset is non-zero and there is an elf at that
// offset, that only part of the file is used.
TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file) {
- MapInfo info(nullptr, 0x100, 0x200, 0x1000, 0, elf_at_1000_.path);
+ MapInfo info(nullptr, nullptr, 0x100, 0x200, 0x1000, 0, elf_at_1000_.path);
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() != nullptr);
@@ -202,7 +203,7 @@
// embedded elf is bigger than the initial map, the new object is larger
// than the original map size. Do this for a 32 bit elf and a 64 bit elf.
TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file_whole_elf32) {
- MapInfo info(nullptr, 0x5000, 0x6000, 0x1000, 0, elf32_at_map_.path);
+ MapInfo info(nullptr, nullptr, 0x5000, 0x6000, 0x1000, 0, elf32_at_map_.path);
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() != nullptr);
@@ -220,7 +221,7 @@
}
TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file_whole_elf64) {
- MapInfo info(nullptr, 0x7000, 0x8000, 0x2000, 0, elf64_at_map_.path);
+ MapInfo info(nullptr, nullptr, 0x7000, 0x8000, 0x2000, 0, elf64_at_map_.path);
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() != nullptr);
@@ -243,14 +244,14 @@
// be returned if the file mapping fails, but the device check is incorrect.
std::vector<uint8_t> buffer(1024);
uint64_t start = reinterpret_cast<uint64_t>(buffer.data());
- MapInfo info(nullptr, start, start + buffer.size(), 0, 0x8000, "/dev/something");
+ MapInfo info(nullptr, nullptr, start, start + buffer.size(), 0, 0x8000, "/dev/something");
std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_));
ASSERT_TRUE(memory.get() == nullptr);
}
TEST_F(MapInfoCreateMemoryTest, process_memory) {
- MapInfo info(nullptr, 0x2000, 0x3000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x2000, 0x3000, 0, PROT_READ, "");
Elf32_Ehdr ehdr = {};
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
diff --git a/libunwindstack/tests/MapInfoGetBuildIDTest.cpp b/libunwindstack/tests/MapInfoGetBuildIDTest.cpp
index 16451d1..6953e26 100644
--- a/libunwindstack/tests/MapInfoGetBuildIDTest.cpp
+++ b/libunwindstack/tests/MapInfoGetBuildIDTest.cpp
@@ -50,7 +50,8 @@
elf_interface_ = new ElfInterfaceFake(memory_);
elf_->FakeSetInterface(elf_interface_);
elf_container_.reset(elf_);
- map_info_.reset(new MapInfo(nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, tf_->path));
+ map_info_.reset(
+ new MapInfo(nullptr, nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, tf_->path));
}
void MultipleThreadTest(std::string expected_build_id);
@@ -64,7 +65,7 @@
};
TEST_F(MapInfoGetBuildIDTest, no_elf_and_no_valid_elf_in_memory) {
- MapInfo info(nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
EXPECT_EQ("", info.GetBuildID());
EXPECT_EQ("", info.GetPrintableBuildID());
diff --git a/libunwindstack/tests/MapInfoGetElfTest.cpp b/libunwindstack/tests/MapInfoGetElfTest.cpp
index d60b8b1..7f97814 100644
--- a/libunwindstack/tests/MapInfoGetElfTest.cpp
+++ b/libunwindstack/tests/MapInfoGetElfTest.cpp
@@ -68,7 +68,7 @@
};
TEST_F(MapInfoGetElfTest, invalid) {
- MapInfo info(nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
// The map is empty, but this should still create an invalid elf object.
Elf* elf = info.GetElf(process_memory_, ARCH_ARM);
@@ -77,7 +77,7 @@
}
TEST_F(MapInfoGetElfTest, valid32) {
- MapInfo info(nullptr, 0x3000, 0x4000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x3000, 0x4000, 0, PROT_READ, "");
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
@@ -97,7 +97,7 @@
}
TEST_F(MapInfoGetElfTest, valid64) {
- MapInfo info(nullptr, 0x8000, 0x9000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x8000, 0x9000, 0, PROT_READ, "");
Elf64_Ehdr ehdr;
TestInitEhdr<Elf64_Ehdr>(&ehdr, ELFCLASS64, EM_AARCH64);
@@ -111,7 +111,7 @@
}
TEST_F(MapInfoGetElfTest, invalid_arch_mismatch) {
- MapInfo info(nullptr, 0x3000, 0x4000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x3000, 0x4000, 0, PROT_READ, "");
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
@@ -123,7 +123,7 @@
}
TEST_F(MapInfoGetElfTest, gnu_debugdata_init32) {
- MapInfo info(nullptr, 0x2000, 0x3000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x2000, 0x3000, 0, PROT_READ, "");
TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, true,
[&](uint64_t offset, const void* ptr, size_t size) {
@@ -139,7 +139,7 @@
}
TEST_F(MapInfoGetElfTest, gnu_debugdata_init64) {
- MapInfo info(nullptr, 0x5000, 0x8000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x5000, 0x8000, 0, PROT_READ, "");
TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, true,
[&](uint64_t offset, const void* ptr, size_t size) {
@@ -155,7 +155,7 @@
}
TEST_F(MapInfoGetElfTest, end_le_start) {
- MapInfo info(nullptr, 0x1000, 0x1000, 0, PROT_READ, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x1000, 0x1000, 0, PROT_READ, elf_.path);
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
@@ -182,7 +182,7 @@
// Verify that if the offset is non-zero but there is no elf at the offset,
// that the full file is used.
TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_full_file) {
- MapInfo info(nullptr, 0x1000, 0x2000, 0x100, PROT_READ, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0x100, PROT_READ, elf_.path);
std::vector<uint8_t> buffer(0x1000);
memset(buffer.data(), 0, buffer.size());
@@ -211,7 +211,7 @@
// Verify that if the offset is non-zero and there is an elf at that
// offset, that only part of the file is used.
TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file) {
- MapInfo info(nullptr, 0x1000, 0x2000, 0x2000, PROT_READ, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0x2000, PROT_READ, elf_.path);
std::vector<uint8_t> buffer(0x4000);
memset(buffer.data(), 0, buffer.size());
@@ -241,7 +241,7 @@
// embedded elf is bigger than the initial map, the new object is larger
// than the original map size. Do this for a 32 bit elf and a 64 bit elf.
TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf32) {
- MapInfo info(nullptr, 0x5000, 0x6000, 0x1000, PROT_READ, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x5000, 0x6000, 0x1000, PROT_READ, elf_.path);
std::vector<uint8_t> buffer(0x4000);
memset(buffer.data(), 0, buffer.size());
@@ -269,7 +269,7 @@
}
TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf64) {
- MapInfo info(nullptr, 0x7000, 0x8000, 0x1000, PROT_READ, elf_.path);
+ MapInfo info(nullptr, nullptr, 0x7000, 0x8000, 0x1000, PROT_READ, elf_.path);
std::vector<uint8_t> buffer(0x4000);
memset(buffer.data(), 0, buffer.size());
@@ -297,7 +297,7 @@
}
TEST_F(MapInfoGetElfTest, check_device_maps) {
- MapInfo info(nullptr, 0x7000, 0x8000, 0x1000, PROT_READ | MAPS_FLAGS_DEVICE_MAP,
+ MapInfo info(nullptr, nullptr, 0x7000, 0x8000, 0x1000, PROT_READ | MAPS_FLAGS_DEVICE_MAP,
"/dev/something");
// Create valid elf data in process memory for this to verify that only
@@ -343,7 +343,7 @@
wait = true;
// Create all of the threads and have them do the GetElf at the same time
// to make it likely that a race will occur.
- MapInfo info(nullptr, 0x7000, 0x8000, 0x1000, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x7000, 0x8000, 0x1000, PROT_READ, "");
for (size_t i = 0; i < kNumConcurrentThreads; i++) {
std::thread* thread = new std::thread([i, this, &wait, &info, &elf_in_threads]() {
while (wait)
@@ -373,8 +373,8 @@
// Verify that previous maps don't automatically get the same elf object.
TEST_F(MapInfoGetElfTest, prev_map_elf_not_set) {
- MapInfo info1(nullptr, 0x1000, 0x2000, 0, PROT_READ, "/not/present");
- MapInfo info2(&info1, 0x2000, 0x3000, 0, PROT_READ, elf_.path);
+ MapInfo info1(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, "/not/present");
+ MapInfo info2(&info1, &info1, 0x2000, 0x3000, 0, PROT_READ, elf_.path);
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
@@ -389,8 +389,25 @@
// Verify that a read-only map followed by a read-execute map will result
// in the same elf object in both maps.
TEST_F(MapInfoGetElfTest, read_only_followed_by_read_exec_share_elf) {
- MapInfo r_info(nullptr, 0x1000, 0x2000, 0, PROT_READ, elf_.path);
- MapInfo rw_info(&r_info, 0x2000, 0x3000, 0x1000, PROT_READ | PROT_EXEC, elf_.path);
+ MapInfo r_info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, elf_.path);
+ MapInfo rw_info(&r_info, &r_info, 0x2000, 0x3000, 0x1000, PROT_READ | PROT_EXEC, elf_.path);
+
+ Elf32_Ehdr ehdr;
+ TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
+ memory_->SetMemory(0x1000, &ehdr, sizeof(ehdr));
+ Elf* elf = rw_info.GetElf(process_memory_, ARCH_ARM);
+ ASSERT_TRUE(elf != nullptr);
+ ASSERT_TRUE(elf->valid());
+
+ ASSERT_EQ(elf, r_info.GetElf(process_memory_, ARCH_ARM));
+}
+
+// Verify that a read-only map followed by an empty map, then followed by
+// a read-execute map will result in the same elf object in both maps.
+TEST_F(MapInfoGetElfTest, read_only_followed_by_empty_then_read_exec_share_elf) {
+ MapInfo r_info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, elf_.path);
+ MapInfo empty(&r_info, &r_info, 0x2000, 0x3000, 0, 0, "");
+ MapInfo rw_info(&empty, &r_info, 0x3000, 0x4000, 0x2000, PROT_READ | PROT_EXEC, elf_.path);
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
diff --git a/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp b/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp
index da3dbf2..971d452 100644
--- a/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp
+++ b/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp
@@ -50,7 +50,7 @@
process_memory_.reset(memory_);
elf_ = new ElfFake(new MemoryFake);
elf_container_.reset(elf_);
- map_info_.reset(new MapInfo(nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, ""));
+ map_info_.reset(new MapInfo(nullptr, nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, ""));
}
void MultipleThreadTest(uint64_t expected_load_bias);
@@ -63,7 +63,7 @@
};
TEST_F(MapInfoGetLoadBiasTest, no_elf_and_no_valid_elf_in_memory) {
- MapInfo info(nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
+ MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
EXPECT_EQ(0U, info.GetLoadBias(process_memory_));
}
diff --git a/libunwindstack/tests/MapInfoTest.cpp b/libunwindstack/tests/MapInfoTest.cpp
index ef76b1b..98edc0e 100644
--- a/libunwindstack/tests/MapInfoTest.cpp
+++ b/libunwindstack/tests/MapInfoTest.cpp
@@ -26,8 +26,8 @@
namespace unwindstack {
TEST(MapInfoTest, maps_constructor_const_char) {
- MapInfo prev_map(nullptr, 0, 0, 0, 0, "");
- MapInfo map_info(&prev_map, 1, 2, 3, 4, "map");
+ MapInfo prev_map(nullptr, nullptr, 0, 0, 0, 0, "");
+ MapInfo map_info(&prev_map, &prev_map, 1, 2, 3, 4, "map");
EXPECT_EQ(&prev_map, map_info.prev_map);
EXPECT_EQ(1UL, map_info.start);
@@ -42,8 +42,8 @@
TEST(MapInfoTest, maps_constructor_string) {
std::string name("string_map");
- MapInfo prev_map(nullptr, 0, 0, 0, 0, "");
- MapInfo map_info(&prev_map, 1, 2, 3, 4, name);
+ MapInfo prev_map(nullptr, nullptr, 0, 0, 0, 0, "");
+ MapInfo map_info(&prev_map, &prev_map, 1, 2, 3, 4, name);
EXPECT_EQ(&prev_map, map_info.prev_map);
EXPECT_EQ(1UL, map_info.start);
@@ -62,7 +62,7 @@
elf->FakeSetInterface(interface);
interface->FakePushFunctionData(FunctionData("function", 1000));
- MapInfo map_info(nullptr, 1, 2, 3, 4, "");
+ MapInfo map_info(nullptr, nullptr, 1, 2, 3, 4, "");
map_info.elf.reset(elf);
std::string name;
diff --git a/libunwindstack/tests/MapsTest.cpp b/libunwindstack/tests/MapsTest.cpp
index 9e7a6ab..724eeb5 100644
--- a/libunwindstack/tests/MapsTest.cpp
+++ b/libunwindstack/tests/MapsTest.cpp
@@ -82,7 +82,7 @@
}
TEST(MapsTest, verify_parse_line) {
- MapInfo info(nullptr, 0, 0, 0, 0, "");
+ MapInfo info(nullptr, nullptr, 0, 0, 0, 0, "");
VerifyLine("01-02 rwxp 03 04:05 06\n", &info);
EXPECT_EQ(1U, info.start);
@@ -155,7 +155,7 @@
}
TEST(MapsTest, verify_large_values) {
- MapInfo info(nullptr, 0, 0, 0, 0, "");
+ MapInfo info(nullptr, nullptr, 0, 0, 0, 0, "");
#if defined(__LP64__)
VerifyLine("fabcdef012345678-f12345678abcdef8 rwxp f0b0d0f010305070 00:00 0\n", &info);
EXPECT_EQ(0xfabcdef012345678UL, info.start);
diff --git a/libunwindstack/tests/RegsTest.cpp b/libunwindstack/tests/RegsTest.cpp
index 472d1cf..0a33e2f 100644
--- a/libunwindstack/tests/RegsTest.cpp
+++ b/libunwindstack/tests/RegsTest.cpp
@@ -182,7 +182,7 @@
RegsX86_64 regs_x86_64;
RegsMips regs_mips;
RegsMips64 regs_mips64;
- MapInfo map_info(nullptr, 0x1000, 0x2000, 0, 0, "");
+ MapInfo map_info(nullptr, nullptr, 0x1000, 0x2000, 0, 0, "");
Elf* invalid_elf = new Elf(nullptr);
map_info.elf.reset(invalid_elf);
diff --git a/libunwindstack/tests/UnwindOfflineTest.cpp b/libunwindstack/tests/UnwindOfflineTest.cpp
index 364101a..c2bd836 100644
--- a/libunwindstack/tests/UnwindOfflineTest.cpp
+++ b/libunwindstack/tests/UnwindOfflineTest.cpp
@@ -169,15 +169,18 @@
};
std::unordered_map<std::string, uint32_t> UnwindOfflineTest::arm64_regs_ = {
- {"x0", ARM64_REG_R0}, {"x1", ARM64_REG_R1}, {"x2", ARM64_REG_R2}, {"x3", ARM64_REG_R3},
- {"x4", ARM64_REG_R4}, {"x5", ARM64_REG_R5}, {"x6", ARM64_REG_R6}, {"x7", ARM64_REG_R7},
- {"x8", ARM64_REG_R8}, {"x9", ARM64_REG_R9}, {"x10", ARM64_REG_R10}, {"x11", ARM64_REG_R11},
- {"x12", ARM64_REG_R12}, {"x13", ARM64_REG_R13}, {"x14", ARM64_REG_R14}, {"x15", ARM64_REG_R15},
- {"x16", ARM64_REG_R16}, {"x17", ARM64_REG_R17}, {"x18", ARM64_REG_R18}, {"x19", ARM64_REG_R19},
- {"x20", ARM64_REG_R20}, {"x21", ARM64_REG_R21}, {"x22", ARM64_REG_R22}, {"x23", ARM64_REG_R23},
- {"x24", ARM64_REG_R24}, {"x25", ARM64_REG_R25}, {"x26", ARM64_REG_R26}, {"x27", ARM64_REG_R27},
- {"x28", ARM64_REG_R28}, {"x29", ARM64_REG_R29}, {"sp", ARM64_REG_SP}, {"lr", ARM64_REG_LR},
- {"pc", ARM64_REG_PC},
+ {"x0", ARM64_REG_R0}, {"x1", ARM64_REG_R1}, {"x2", ARM64_REG_R2},
+ {"x3", ARM64_REG_R3}, {"x4", ARM64_REG_R4}, {"x5", ARM64_REG_R5},
+ {"x6", ARM64_REG_R6}, {"x7", ARM64_REG_R7}, {"x8", ARM64_REG_R8},
+ {"x9", ARM64_REG_R9}, {"x10", ARM64_REG_R10}, {"x11", ARM64_REG_R11},
+ {"x12", ARM64_REG_R12}, {"x13", ARM64_REG_R13}, {"x14", ARM64_REG_R14},
+ {"x15", ARM64_REG_R15}, {"x16", ARM64_REG_R16}, {"x17", ARM64_REG_R17},
+ {"x18", ARM64_REG_R18}, {"x19", ARM64_REG_R19}, {"x20", ARM64_REG_R20},
+ {"x21", ARM64_REG_R21}, {"x22", ARM64_REG_R22}, {"x23", ARM64_REG_R23},
+ {"x24", ARM64_REG_R24}, {"x25", ARM64_REG_R25}, {"x26", ARM64_REG_R26},
+ {"x27", ARM64_REG_R27}, {"x28", ARM64_REG_R28}, {"x29", ARM64_REG_R29},
+ {"sp", ARM64_REG_SP}, {"lr", ARM64_REG_LR}, {"pc", ARM64_REG_PC},
+ {"pst", ARM64_REG_PSTATE},
};
std::unordered_map<std::string, uint32_t> UnwindOfflineTest::x86_regs_ = {
@@ -1697,4 +1700,40 @@
EXPECT_EQ(0xffe67d10ULL, unwinder.frames()[16].sp);
}
+TEST_F(UnwindOfflineTest, empty_arm64) {
+ ASSERT_NO_FATAL_FAILURE(Init("empty_arm64/", ARCH_ARM64));
+
+ Unwinder unwinder(128, maps_.get(), regs_.get(), process_memory_);
+ unwinder.Unwind();
+
+ std::string frame_info(DumpFrames(unwinder));
+ ASSERT_EQ(7U, unwinder.NumFrames()) << "Unwind:\n" << frame_info;
+ EXPECT_EQ(
+ " #00 pc 00000000000963a4 libc.so (__ioctl+4)\n"
+ " #01 pc 000000000005344c libc.so (ioctl+140)\n"
+ " #02 pc 0000000000050ce4 libbinder.so "
+ "(android::IPCThreadState::talkWithDriver(bool)+308)\n"
+ " #03 pc 0000000000050e98 libbinder.so "
+ "(android::IPCThreadState::getAndExecuteCommand()+24)\n"
+ " #04 pc 00000000000516ac libbinder.so (android::IPCThreadState::joinThreadPool(bool)+60)\n"
+ " #05 pc 00000000000443b0 netd (main+1056)\n"
+ " #06 pc 0000000000045594 libc.so (__libc_init+108)\n",
+ frame_info);
+
+ EXPECT_EQ(0x72a02203a4U, unwinder.frames()[0].pc);
+ EXPECT_EQ(0x7ffb6c0b50U, unwinder.frames()[0].sp);
+ EXPECT_EQ(0x72a01dd44cU, unwinder.frames()[1].pc);
+ EXPECT_EQ(0x7ffb6c0b50U, unwinder.frames()[1].sp);
+ EXPECT_EQ(0x729f759ce4U, unwinder.frames()[2].pc);
+ EXPECT_EQ(0x7ffb6c0c50U, unwinder.frames()[2].sp);
+ EXPECT_EQ(0x729f759e98U, unwinder.frames()[3].pc);
+ EXPECT_EQ(0x7ffb6c0ce0U, unwinder.frames()[3].sp);
+ EXPECT_EQ(0x729f75a6acU, unwinder.frames()[4].pc);
+ EXPECT_EQ(0x7ffb6c0d10U, unwinder.frames()[4].sp);
+ EXPECT_EQ(0x5d478af3b0U, unwinder.frames()[5].pc);
+ EXPECT_EQ(0x7ffb6c0d40U, unwinder.frames()[5].sp);
+ EXPECT_EQ(0x72a01cf594U, unwinder.frames()[6].pc);
+ EXPECT_EQ(0x7ffb6c0f30U, unwinder.frames()[6].sp);
+}
+
} // namespace unwindstack
diff --git a/libunwindstack/tests/files/offline/empty_arm64/libbinder.so b/libunwindstack/tests/files/offline/empty_arm64/libbinder.so
new file mode 100644
index 0000000..f30384c
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/libbinder.so
Binary files differ
diff --git a/libunwindstack/tests/files/offline/empty_arm64/libc.so b/libunwindstack/tests/files/offline/empty_arm64/libc.so
new file mode 100644
index 0000000..b05dcaf
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/libc.so
Binary files differ
diff --git a/libunwindstack/tests/files/offline/empty_arm64/maps.txt b/libunwindstack/tests/files/offline/empty_arm64/maps.txt
new file mode 100644
index 0000000..edb83c6
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/maps.txt
@@ -0,0 +1,9 @@
+5d4786b000-5d47893000 r--p 0 00:00 0 netd
+5d47893000-5d47894000 ---p 0 00:00 0
+5d47894000-5d47901000 --xp 29000 00:00 0 netd
+729f709000-729f750000 r--p 0 00:00 0 libbinder.so
+729f750000-729f751000 ---p 0 00:00 0
+729f751000-729f794000 --xp 48000 00:00 0 libbinder.so
+72a018a000-72a01c2000 r--p 0 00:00 0 libc.so
+72a01c2000-72a01c3000 ---p 0 00:00 0
+72a01c3000-72a023b000 --xp 39000 00:00 0 libc.so
diff --git a/libunwindstack/tests/files/offline/empty_arm64/netd b/libunwindstack/tests/files/offline/empty_arm64/netd
new file mode 100644
index 0000000..8a72e94
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/netd
Binary files differ
diff --git a/libunwindstack/tests/files/offline/empty_arm64/regs.txt b/libunwindstack/tests/files/offline/empty_arm64/regs.txt
new file mode 100644
index 0000000..3d4279f
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/regs.txt
@@ -0,0 +1,34 @@
+x0: 1d
+x1: c0306201
+x2: 7ffb6c0c50
+x3: 0
+x4: 0
+x5: 0
+x6: 0
+x7: 0
+x8: 1d
+x9: 7ffb6c0c00
+x10: 7ffb6c0c50
+x11: 7ffb6c0bd0
+x12: ffffff80ffffffd0
+x13: 0
+x14: 72a0240ce2
+x15: 20
+x16: 729f7a54e8
+x17: 72a01dd3c0
+x18: 72a0ac2000
+x19: 72a0666000
+x20: 719769b610
+x21: 719769b730
+x22: c0306201
+x23: fffffff7
+x24: 72a0666000
+x25: 0
+x26: 0
+x27: 0
+x28: 0
+x29: 7ffb6c0c30
+sp: 7ffb6c0b50
+lr: 72a01dd450
+pc: 72a02203a4
+pst: a0000000
diff --git a/libunwindstack/tests/files/offline/empty_arm64/stack.data b/libunwindstack/tests/files/offline/empty_arm64/stack.data
new file mode 100644
index 0000000..6d6108c
--- /dev/null
+++ b/libunwindstack/tests/files/offline/empty_arm64/stack.data
Binary files differ
diff --git a/logcat/logcat.cpp b/logcat/logcat.cpp
index 7b18438..08e3d22 100644
--- a/logcat/logcat.cpp
+++ b/logcat/logcat.cpp
@@ -110,7 +110,7 @@
#endif
static int openLogFile(const char* pathname, size_t sizeKB) {
- int fd = open(pathname, O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, S_IRUSR | S_IWUSR);
+ int fd = open(pathname, O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, S_IRUSR | S_IWUSR | S_IRGRP);
if (fd < 0) {
return fd;
}
diff --git a/logcat/logcatd b/logcat/logcatd
index 622e567..5a1415d 100755
--- a/logcat/logcatd
+++ b/logcat/logcatd
@@ -4,6 +4,10 @@
# first reads the 'last' logcat to persistent storage with `-L` then run logcat again without
# `-L` to read the current logcat buffers to persistent storage.
+# init sets the umask to 077 for forked processes. logpersist needs to create files that are group
+# readable. So relax the umask to only disallow group wx and world rwx.
+umask 037
+
has_last="false"
for arg in "$@"; do
if [ "$arg" == "-L" -o "$arg" == "--last" ]; then
diff --git a/logcat/logcatd.rc b/logcat/logcatd.rc
index e986184..64d5500 100644
--- a/logcat/logcatd.rc
+++ b/logcat/logcatd.rc
@@ -30,8 +30,8 @@
setprop logd.logpersistd.enable true
on property:logd.logpersistd.enable=true && property:logd.logpersistd=logcatd
- # all exec/services are called with umask(077), so no gain beyond 0700
- mkdir /data/misc/logd 0700 logd log
+ # log group should be able to read persisted logs
+ mkdir /data/misc/logd 0750 logd log
start logcatd
# stop logcatd service and clear data
diff --git a/logd/logtagd.rc b/logd/logtagd.rc
index 46aa8c1..248a78c 100644
--- a/logd/logtagd.rc
+++ b/logd/logtagd.rc
@@ -2,7 +2,7 @@
# logtagd event log tag service (debug only)
#
on post-fs-data
- mkdir /data/misc/logd 0700 logd log
+ mkdir /data/misc/logd 0750 logd log
write /data/misc/logd/event-log-tags ""
chown logd log /data/misc/logd/event-log-tags
chmod 0600 /data/misc/logd/event-log-tags
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 5821379..a9d0ed0 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -67,6 +67,11 @@
EXPORT_GLOBAL_GCOV_OPTIONS := export GCOV_PREFIX /data/misc/trace
endif
+EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
+ifeq ($(CLANG_COVERAGE),true)
+ EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%p-%m.profraw
+endif
+
# Put it here instead of in init.rc module definition,
# because init.rc is conditionally included.
#
@@ -147,6 +152,7 @@
$(hide) sed -i -e 's?%SYSTEMSERVERCLASSPATH%?$(PRODUCT_SYSTEM_SERVER_CLASSPATH)?g' $@
$(hide) sed -i -e 's?%EXPORT_GLOBAL_ASAN_OPTIONS%?$(EXPORT_GLOBAL_ASAN_OPTIONS)?g' $@
$(hide) sed -i -e 's?%EXPORT_GLOBAL_GCOV_OPTIONS%?$(EXPORT_GLOBAL_GCOV_OPTIONS)?g' $@
+ $(hide) sed -i -e 's?%EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%?$(EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS)?g' $@
$(hide) sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?$(EXPORT_GLOBAL_HWASAN_OPTIONS)?g' $@
# Append PLATFORM_VNDK_VERSION to base name.
diff --git a/rootdir/init.environ.rc.in b/rootdir/init.environ.rc.in
index 50005d9..fdaaf1a 100644
--- a/rootdir/init.environ.rc.in
+++ b/rootdir/init.environ.rc.in
@@ -15,4 +15,5 @@
export SYSTEMSERVERCLASSPATH %SYSTEMSERVERCLASSPATH%
%EXPORT_GLOBAL_ASAN_OPTIONS%
%EXPORT_GLOBAL_GCOV_OPTIONS%
+ %EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%
%EXPORT_GLOBAL_HWASAN_OPTIONS%
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 6a6169c..e575808 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -173,7 +173,7 @@
mkdir /mnt/user/0/emulated/0 0755 root root
# Prepare directories for pass through processes
- mkdir /mnt/pass_through 0755 root root
+ mkdir /mnt/pass_through 0700 root root
mkdir /mnt/pass_through/0 0755 root root
mkdir /mnt/pass_through/0/self 0755 root root
mkdir /mnt/pass_through/0/emulated 0755 root root