Merge "Make memunreachable_test more robust against false negative leaks"
diff --git a/adb/daemon/remount_service.cpp b/adb/daemon/remount_service.cpp
index d679a6d..7876368 100644
--- a/adb/daemon/remount_service.cpp
+++ b/adb/daemon/remount_service.cpp
@@ -25,14 +25,18 @@
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
+#include <sys/vfs.h>
#include <unistd.h>
#include <string>
+#include <vector>
#include <android-base/properties.h>
+#include <ext4_utils/ext4_utils.h>
#include "adb.h"
#include "adb_io.h"
+#include "adb_unique_fd.h"
#include "adb_utils.h"
#include "fs_mgr.h"
@@ -82,7 +86,27 @@
return result;
}
-static bool remount_partition(int fd, const char* dir) {
+static bool fs_has_shared_blocks(const char* dev) {
+ struct statfs fs;
+ if (statfs(dev, &fs) == -1 || fs.f_type == EXT4_SUPER_MAGIC) {
+ return false;
+ }
+ unique_fd fd(unix_open(dev, O_RDONLY));
+ if (fd < 0) {
+ return false;
+ }
+ struct ext4_super_block sb;
+ if (lseek64(fd, 1024, SEEK_SET) < 0 || unix_read(fd, &sb, sizeof(sb)) < 0) {
+ return false;
+ }
+ struct fs_info info;
+ if (ext4_parse_sb(&sb, &info) < 0) {
+ return false;
+ }
+ return (info.feat_ro_compat & EXT4_FEATURE_RO_COMPAT_SHARED_BLOCKS) != 0;
+}
+
+static bool remount_partition(int fd, const char* dir, std::vector<std::string>& dedup) {
if (!directory_exists(dir)) {
return true;
}
@@ -108,6 +132,12 @@
return false;
}
if (mount(dev.c_str(), dir, "none", MS_REMOUNT, nullptr) == -1) {
+ if (errno == EROFS && fs_has_shared_blocks(dev.c_str())) {
+ // We return true so remount_service() can detect that the only
+ // failure was deduplicated filesystems.
+ dedup.push_back(dev);
+ return true;
+ }
WriteFdFmt(fd, "remount of the %s superblock failed: %s\n", dir, strerror(errno));
return false;
}
@@ -140,17 +170,29 @@
}
bool success = true;
+ std::vector<std::string> dedup;
if (android::base::GetBoolProperty("ro.build.system_root_image", false)) {
- success &= remount_partition(fd, "/");
+ success &= remount_partition(fd, "/", dedup);
} else {
- success &= remount_partition(fd, "/system");
+ success &= remount_partition(fd, "/system", dedup);
}
- success &= remount_partition(fd, "/odm");
- success &= remount_partition(fd, "/oem");
- success &= remount_partition(fd, "/product");
- success &= remount_partition(fd, "/vendor");
+ success &= remount_partition(fd, "/odm", dedup);
+ success &= remount_partition(fd, "/oem", dedup);
+ success &= remount_partition(fd, "/product", dedup);
+ success &= remount_partition(fd, "/vendor", dedup);
- WriteFdExactly(fd, success ? "remount succeeded\n" : "remount failed\n");
+ if (!success) {
+ WriteFdExactly(fd, "remount failed\n");
+ } else if (dedup.empty()) {
+ WriteFdExactly(fd, "remount succeeded\n");
+ } else {
+ WriteFdExactly(fd,
+ "The following partitions are deduplicated and could "
+ "not be remounted:\n");
+ for (const std::string& name : dedup) {
+ WriteFdFmt(fd, " %s\n", name.c_str());
+ }
+ }
adb_close(fd);
}
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 9b64be7..dfb7a6a 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -80,8 +80,13 @@
return value; \
}()
+// Backtrace frame dump could contain:
+// #01 pc 0001cded /data/tmp/debuggerd_test32 (raise_debugger_signal+80)
+// or
+// #01 pc 00022a09 /data/tmp/debuggerd_test32 (offset 0x12000) (raise_debugger_signal+80)
#define ASSERT_BACKTRACE_FRAME(result, frame_name) \
- ASSERT_MATCH(result, R"(#\d\d pc [0-9a-f]+\s+ \S+ \()" frame_name R"(\+)");
+ ASSERT_MATCH(result, \
+ R"(#\d\d pc [0-9a-f]+\s+ \S+ (\(offset 0x[0-9a-f]+\) )?\()" frame_name R"(\+)");
static void tombstoned_intercept(pid_t target_pid, unique_fd* intercept_fd, unique_fd* output_fd,
InterceptStatus* status, DebuggerdDumpType intercept_type) {
diff --git a/init/keychords.cpp b/init/keychords.cpp
index f55d2c4..293736d 100644
--- a/init/keychords.cpp
+++ b/init/keychords.cpp
@@ -20,12 +20,14 @@
#include <fcntl.h>
#include <linux/input.h>
#include <sys/cdefs.h>
+#include <sys/inotify.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <unistd.h>
#include <algorithm>
#include <functional>
+#include <map>
#include <memory>
#include <string>
#include <vector>
@@ -118,6 +120,8 @@
constexpr char kDevicePath[] = "/dev/input";
+std::map<std::string, int> keychord_registration;
+
void HandleKeychord(int id) {
// Only handle keychords if adb is enabled.
std::string adb_enabled = android::base::GetProperty("init.svc.adbd", "");
@@ -215,6 +219,7 @@
}
void GeteventOpenDevice(const std::string& device) {
+ if (keychord_registration.count(device)) return;
auto fd = TEMP_FAILURE_RETRY(::open(device.c_str(), O_RDWR | O_CLOEXEC));
if (fd == -1) {
PLOG(ERROR) << "Can not open " << device;
@@ -222,21 +227,74 @@
}
if (!KeychordGeteventEnable(fd)) {
::close(fd);
+ } else {
+ keychord_registration.emplace(device, fd);
+ }
+}
+
+void GeteventCloseDevice(const std::string& device) {
+ auto it = keychord_registration.find(device);
+ if (it == keychord_registration.end()) return;
+ auto fd = (*it).second;
+ unregister_epoll_handler(fd);
+ keychord_registration.erase(it);
+ ::close(fd);
+}
+
+int inotify_fd = -1;
+
+void InotifyHandler() {
+ unsigned char buf[512];
+
+ auto res = TEMP_FAILURE_RETRY(::read(inotify_fd, buf, sizeof(buf)));
+ if (res < 0) {
+ PLOG(WARNING) << "could not get event";
+ return;
+ }
+
+ auto event_buf = buf;
+ while (static_cast<size_t>(res) >= sizeof(inotify_event)) {
+ auto event = reinterpret_cast<inotify_event*>(event_buf);
+ auto event_size = sizeof(inotify_event) + event->len;
+ if (static_cast<size_t>(res) < event_size) break;
+ if (event->len) {
+ std::string devname(kDevicePath);
+ devname += '/';
+ devname += event->name;
+ if (event->mask & IN_CREATE) {
+ GeteventOpenDevice(devname);
+ } else {
+ GeteventCloseDevice(devname);
+ }
+ }
+ res -= event_size;
+ event_buf += event_size;
}
}
void GeteventOpenDevice() {
- std::unique_ptr<DIR, decltype(&closedir)> device(opendir(kDevicePath), closedir);
- if (!device) return;
-
- dirent* entry;
- while ((entry = readdir(device.get()))) {
- if (entry->d_name[0] == '.') continue;
- std::string devname(kDevicePath);
- devname += '/';
- devname += entry->d_name;
- GeteventOpenDevice(devname);
+ inotify_fd = ::inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+ if (inotify_fd < 0) {
+ PLOG(WARNING) << "Could not instantiate inotify for " << kDevicePath;
+ } else if (::inotify_add_watch(inotify_fd, kDevicePath, IN_DELETE | IN_CREATE | IN_ONLYDIR) < 0) {
+ PLOG(WARNING) << "Could not add watch for " << kDevicePath;
+ ::close(inotify_fd);
+ inotify_fd = -1;
}
+
+ std::unique_ptr<DIR, decltype(&closedir)> device(opendir(kDevicePath), closedir);
+ if (device) {
+ dirent* entry;
+ while ((entry = readdir(device.get()))) {
+ if (entry->d_name[0] == '.') continue;
+ std::string devname(kDevicePath);
+ devname += '/';
+ devname += entry->d_name;
+ GeteventOpenDevice(devname);
+ }
+ }
+
+ if (inotify_fd >= 0) register_epoll_handler(inotify_fd, InotifyHandler);
}
void AddServiceKeycodes(Service* svc) {
diff --git a/libunwindstack/ElfInterface.cpp b/libunwindstack/ElfInterface.cpp
index 10afe33..4c05a1b 100644
--- a/libunwindstack/ElfInterface.cpp
+++ b/libunwindstack/ElfInterface.cpp
@@ -87,8 +87,8 @@
ISzAlloc alloc;
CXzUnpacker state;
- alloc.Alloc = [](void*, size_t size) { return malloc(size); };
- alloc.Free = [](void*, void* ptr) { return free(ptr); };
+ alloc.Alloc = [](ISzAllocPtr, size_t size) { return malloc(size); };
+ alloc.Free = [](ISzAllocPtr, void* ptr) { return free(ptr); };
XzUnpacker_Construct(&state, &alloc);
@@ -106,7 +106,7 @@
dst_remaining += 2 * gnu_debugdata_size_;
}
return_val = XzUnpacker_Code(&state, dst->GetPtr(dst_offset), &dst_remaining, &src[src_offset],
- &src_remaining, CODER_FINISH_ANY, &status);
+ &src_remaining, true, CODER_FINISH_ANY, &status);
src_offset += src_remaining;
dst_offset += dst_remaining;
} while (return_val == SZ_OK && status == CODER_STATUS_NOT_FINISHED);
