Merge changes from topic "remove_ashmemd"
* changes:
libcutils: route to /dev/ashmem<boot_id> instead of ashmemd
ueventd: duplicate /dev/ashmem
diff --git a/adb/Android.bp b/adb/Android.bp
index 57872b0..3dc70b5 100644
--- a/adb/Android.bp
+++ b/adb/Android.bp
@@ -253,7 +253,7 @@
"libbase",
"libcutils",
"libcrypto_utils",
- "libcrypto",
+ "libcrypto_static",
"libdiagnose_usb",
"liblog",
"libusb",
@@ -553,7 +553,7 @@
"libbase",
"libbootloader_message",
"libcap",
- "libcrypto",
+ "libcrypto_static",
"libcrypto_utils",
"libcutils",
"libdiagnose_usb",
@@ -621,7 +621,7 @@
"libbootloader_message",
"libcutils",
"libcrypto_utils",
- "libcrypto",
+ "libcrypto_static",
"libdiagnose_usb",
"liblog",
"libusb",
@@ -629,6 +629,7 @@
"libselinux",
],
test_suites: ["device-tests"],
+ require_root: true,
}
python_test_host {
diff --git a/adb/client/file_sync_client.cpp b/adb/client/file_sync_client.cpp
index 5d10238..703eb2f 100644
--- a/adb/client/file_sync_client.cpp
+++ b/adb/client/file_sync_client.cpp
@@ -849,6 +849,16 @@
return true;
}
+// dirname("//foo") returns "//", so we can't do the obvious `path == "/"`.
+static bool is_root_dir(std::string_view path) {
+ for (char c : path) {
+ if (c != '/') {
+ return false;
+ }
+ }
+ return true;
+}
+
static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath,
std::string rpath, bool check_timestamps,
bool list_only) {
@@ -862,8 +872,8 @@
std::vector<copyinfo> file_list;
std::vector<std::string> directory_list;
- for (std::string dirpath = rpath; dirpath != "/"; dirpath = android::base::Dirname(dirpath)) {
- directory_list.push_back(dirpath);
+ for (std::string path = rpath; !is_root_dir(path); path = android::base::Dirname(path)) {
+ directory_list.push_back(path);
}
std::reverse(directory_list.begin(), directory_list.end());
diff --git a/adb/client/usb_linux.cpp b/adb/client/usb_linux.cpp
index 17b4db1..24e722e 100644
--- a/adb/client/usb_linux.cpp
+++ b/adb/client/usb_linux.cpp
@@ -406,25 +406,44 @@
}
}
-int usb_write(usb_handle *h, const void *_data, int len)
-{
+static int usb_write_split(usb_handle* h, unsigned char* data, int len) {
+ for (int i = 0; i < len; i += 16384) {
+ int chunk_size = (i + 16384 > len) ? len - i : 16384;
+ int n = usb_bulk_write(h, data + i, chunk_size);
+ if (n != chunk_size) {
+ D("ERROR: n = %d, errno = %d (%s)", n, errno, strerror(errno));
+ return -1;
+ }
+ }
+
+ return len;
+}
+
+int usb_write(usb_handle* h, const void* _data, int len) {
D("++ usb_write ++");
- unsigned char *data = (unsigned char*) _data;
+ unsigned char* data = (unsigned char*)_data;
+
+ // The kernel will attempt to allocate a contiguous buffer for each write we submit.
+ // This might fail due to heap fragmentation, so attempt a contiguous write once, and if that
+ // fails, retry after having split the data into 16kB chunks to avoid allocation failure.
int n = usb_bulk_write(h, data, len);
- if (n != len) {
- D("ERROR: n = %d, errno = %d (%s)", n, errno, strerror(errno));
+ if (n == -1 && errno == ENOMEM) {
+ n = usb_write_split(h, data, len);
+ }
+
+ if (n == -1) {
return -1;
}
if (h->zero_mask && !(len & h->zero_mask)) {
// If we need 0-markers and our transfer is an even multiple of the packet size,
// then send a zero marker.
- return usb_bulk_write(h, _data, 0) == 0 ? n : -1;
+ return usb_bulk_write(h, _data, 0) == 0 ? len : -1;
}
D("-- usb_write --");
- return n;
+ return len;
}
int usb_read(usb_handle *h, void *_data, int len)
diff --git a/adb/test_device.py b/adb/test_device.py
index dbd80ed..32d797e 100755
--- a/adb/test_device.py
+++ b/adb/test_device.py
@@ -903,6 +903,18 @@
remote_path += '/filename'
self.device.push(local=tmp_file.name, remote=remote_path)
+ def test_push_multiple_slash_root(self):
+ """Regression test for pushing to //data/local/tmp.
+
+ Bug: http://b/141311284
+ """
+ with tempfile.NamedTemporaryFile() as tmp_file:
+ tmp_file.write('\0' * 1024 * 1024)
+ tmp_file.flush()
+ remote_path = '/' + self.DEVICE_TEMP_DIR + '/test_push_multiple_slash_root'
+ self.device.shell(['rm', '-rf', remote_path])
+ self.device.push(local=tmp_file.name, remote=remote_path)
+
def _test_pull(self, remote_file, checksum):
tmp_write = tempfile.NamedTemporaryFile(mode='wb', delete=False)
tmp_write.close()
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index c617c6c..c9a193c 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -195,9 +195,7 @@
void CrasherTest::FinishIntercept(int* result) {
InterceptResponse response;
- // Timeout for tombstoned intercept is 10 seconds.
- ssize_t rc =
- TIMEOUT(20, TEMP_FAILURE_RETRY(read(intercept_fd.get(), &response, sizeof(response))));
+ ssize_t rc = TIMEOUT(30, read(intercept_fd.get(), &response, sizeof(response)));
if (rc == -1) {
FAIL() << "failed to read response from tombstoned: " << strerror(errno);
} else if (rc == 0) {
@@ -244,7 +242,7 @@
void CrasherTest::AssertDeath(int signo) {
int status;
- pid_t pid = TIMEOUT(10, TEMP_FAILURE_RETRY(waitpid(crasher_pid, &status, 0)));
+ pid_t pid = TIMEOUT(30, waitpid(crasher_pid, &status, 0));
if (pid != crasher_pid) {
printf("failed to wait for crasher (expected pid %d, return value %d): %s\n", crasher_pid, pid,
strerror(errno));
diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index 546bce2..f452a64 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -189,7 +189,11 @@
// will violate ODR.
shared_libs: [],
- header_libs: ["bootimg_headers"],
+ header_libs: [
+ "avb_headers",
+ "bootimg_headers",
+ ],
+
static_libs: [
"libziparchive",
"libsparse",
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index a7fc628..2fe3b1a 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -51,6 +51,7 @@
#include <utility>
#include <vector>
+#include <android-base/endian.h>
#include <android-base/file.h>
#include <android-base/macros.h>
#include <android-base/parseint.h>
@@ -59,6 +60,7 @@
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include <build/version.h>
+#include <libavb/libavb.h>
#include <liblp/liblp.h>
#include <platform_tools_version.h>
#include <sparse/sparse.h>
@@ -919,33 +921,50 @@
return load_buf_fd(fd.release(), buf);
}
-static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf) {
+static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf, bool vbmeta_in_boot) {
// Buffer needs to be at least the size of the VBMeta struct which
// is 256 bytes.
if (buf->sz < 256) {
return;
}
- int fd = make_temporary_fd("vbmeta rewriting");
-
std::string data;
if (!android::base::ReadFdToString(buf->fd, &data)) {
die("Failed reading from vbmeta");
}
+ uint64_t vbmeta_offset = 0;
+ if (vbmeta_in_boot) {
+ // Tries to locate top-level vbmeta from boot.img footer.
+ uint64_t footer_offset = buf->sz - AVB_FOOTER_SIZE;
+ if (0 != data.compare(footer_offset, AVB_FOOTER_MAGIC_LEN, AVB_FOOTER_MAGIC)) {
+ die("Failed to find AVB_FOOTER at offset: %" PRId64, footer_offset);
+ }
+ const AvbFooter* footer = reinterpret_cast<const AvbFooter*>(data.c_str() + footer_offset);
+ vbmeta_offset = be64toh(footer->vbmeta_offset);
+ }
+ // Ensures there is AVB_MAGIC at vbmeta_offset.
+ if (0 != data.compare(vbmeta_offset, AVB_MAGIC_LEN, AVB_MAGIC)) {
+ die("Failed to find AVB_MAGIC at offset: %" PRId64, vbmeta_offset);
+ }
+
+ fprintf(stderr, "Rewriting vbmeta struct at offset: %" PRId64 "\n", vbmeta_offset);
+
// There's a 32-bit big endian |flags| field at offset 120 where
// bit 0 corresponds to disable-verity and bit 1 corresponds to
// disable-verification.
//
// See external/avb/libavb/avb_vbmeta_image.h for the layout of
// the VBMeta struct.
+ uint64_t flags_offset = 123 + vbmeta_offset;
if (g_disable_verity) {
- data[123] |= 0x01;
+ data[flags_offset] |= 0x01;
}
if (g_disable_verification) {
- data[123] |= 0x02;
+ data[flags_offset] |= 0x02;
}
+ int fd = make_temporary_fd("vbmeta rewriting");
if (!android::base::WriteStringToFd(data, fd)) {
die("Failed writing to modified vbmeta");
}
@@ -954,14 +973,25 @@
lseek(fd, 0, SEEK_SET);
}
+static bool has_vbmeta_partition() {
+ std::string partition_type;
+ return fb->GetVar("partition-type:vbmeta", &partition_type) == fastboot::SUCCESS ||
+ fb->GetVar("partition-type:vbmeta_a", &partition_type) == fastboot::SUCCESS ||
+ fb->GetVar("partition-type:vbmeta_b", &partition_type) == fastboot::SUCCESS;
+}
+
static void flash_buf(const std::string& partition, struct fastboot_buffer *buf)
{
sparse_file** s;
// Rewrite vbmeta if that's what we're flashing and modification has been requested.
- if ((g_disable_verity || g_disable_verification) &&
- (partition == "vbmeta" || partition == "vbmeta_a" || partition == "vbmeta_b")) {
- rewrite_vbmeta_buffer(buf);
+ if (g_disable_verity || g_disable_verification) {
+ if (partition == "vbmeta" || partition == "vbmeta_a" || partition == "vbmeta_b") {
+ rewrite_vbmeta_buffer(buf, false /* vbmeta_in_boot */);
+ } else if (!has_vbmeta_partition() &&
+ (partition == "boot" || partition == "boot_a" || partition == "boot_b")) {
+ rewrite_vbmeta_buffer(buf, true /* vbmeta_in_boot */ );
+ }
}
switch (buf->type) {
diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index 4dbacd7..e50f7c3 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -36,6 +36,7 @@
#include "fs_mgr_priv.h"
+using android::base::EndsWith;
using android::base::ParseByteCount;
using android::base::ParseInt;
using android::base::ReadFileToString;
@@ -598,7 +599,7 @@
return boot_devices;
}
-FstabEntry BuildGsiUserdataFstabEntry() {
+FstabEntry BuildDsuUserdataFstabEntry() {
constexpr uint32_t kFlags = MS_NOATIME | MS_NOSUID | MS_NODEV;
FstabEntry userdata = {
@@ -627,7 +628,12 @@
return false;
}
-void TransformFstabForGsi(Fstab* fstab) {
+} // namespace
+
+void TransformFstabForDsu(Fstab* fstab, const std::vector<std::string>& dsu_partitions) {
+ static constexpr char kGsiKeys[] =
+ "/avb/q-gsi.avbpubkey:/avb/r-gsi.avbpubkey:/avb/s-gsi.avbpubkey";
+ // Convert userdata
// Inherit fstab properties for userdata.
FstabEntry userdata;
if (FstabEntry* entry = GetEntryForMountPoint(fstab, "/data")) {
@@ -639,19 +645,75 @@
userdata.key_dir += "/gsi";
}
} else {
- userdata = BuildGsiUserdataFstabEntry();
- }
-
- if (EraseFstabEntry(fstab, "/system")) {
- fstab->emplace_back(BuildGsiSystemFstabEntry());
+ userdata = BuildDsuUserdataFstabEntry();
}
if (EraseFstabEntry(fstab, "/data")) {
fstab->emplace_back(userdata);
}
-}
-} // namespace
+ // Convert others
+ for (auto&& partition : dsu_partitions) {
+ if (!EndsWith(partition, gsi::kDsuPostfix)) {
+ continue;
+ }
+ // userdata has been handled
+ if (StartsWith(partition, "user")) {
+ continue;
+ }
+ // dsu_partition_name = corresponding_partition_name + kDsuPostfix
+ // e.g.
+ // system_gsi for system
+ // product_gsi for product
+ // vendor_gsi for vendor
+ std::string lp_name = partition.substr(0, partition.length() - strlen(gsi::kDsuPostfix));
+ std::string mount_point = "/" + lp_name;
+ std::vector<FstabEntry*> entries = GetEntriesForMountPoint(fstab, mount_point);
+ if (entries.empty()) {
+ FstabEntry entry = {
+ .blk_device = partition,
+ .mount_point = mount_point,
+ .fs_type = "ext4",
+ .flags = MS_RDONLY,
+ .fs_options = "barrier=1",
+ .avb_keys = kGsiKeys,
+ // .logical_partition_name is required to look up AVB Hashtree descriptors.
+ .logical_partition_name = "system"};
+ entry.fs_mgr_flags.wait = true;
+ entry.fs_mgr_flags.logical = true;
+ entry.fs_mgr_flags.first_stage_mount = true;
+ // Use the system key which may be in the vbmeta or vbmeta_system
+ // TODO: b/141284191
+ entry.vbmeta_partition = "vbmeta";
+ fstab->emplace_back(entry);
+ entry.vbmeta_partition = "vbmeta_system";
+ fstab->emplace_back(entry);
+ } else {
+ // If the corresponding partition exists, transform all its Fstab
+ // by pointing .blk_device to the DSU partition.
+ for (auto&& entry : entries) {
+ entry->blk_device = partition;
+ if (entry->avb_keys.size() > 0) {
+ entry->avb_keys += ":";
+ }
+ // If the DSU is signed by OEM, the original Fstab already has the information
+ // required by avb, otherwise the DSU is GSI and will need the avb_keys as listed
+ // below.
+ entry->avb_keys += kGsiKeys;
+ }
+ // Make sure the ext4 is included to support GSI.
+ auto partition_ext4 =
+ std::find_if(fstab->begin(), fstab->end(), [&](const auto& entry) {
+ return entry.mount_point == mount_point && entry.fs_type == "ext4";
+ });
+ if (partition_ext4 == fstab->end()) {
+ auto new_entry = *GetEntryForMountPoint(fstab, mount_point);
+ new_entry.fs_type = "ext4";
+ fstab->emplace_back(new_entry);
+ }
+ }
+ }
+}
bool ReadFstabFromFile(const std::string& path, Fstab* fstab) {
auto fstab_file = std::unique_ptr<FILE, decltype(&fclose)>{fopen(path.c_str(), "re"), fclose};
@@ -667,7 +729,9 @@
return false;
}
if (!is_proc_mounts && !access(android::gsi::kGsiBootedIndicatorFile, F_OK)) {
- TransformFstabForGsi(fstab);
+ std::string lp_names;
+ ReadFileToString(gsi::kGsiLpNamesFile, &lp_names);
+ TransformFstabForDsu(fstab, Split(lp_names, ","));
}
SkipMountingPartitions(fstab);
@@ -779,6 +843,21 @@
return nullptr;
}
+std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string& path) {
+ std::vector<FstabEntry*> entries;
+ if (fstab == nullptr) {
+ return entries;
+ }
+
+ for (auto& entry : *fstab) {
+ if (entry.mount_point == path) {
+ entries.emplace_back(&entry);
+ }
+ }
+
+ return entries;
+}
+
std::set<std::string> GetBootDevices() {
// First check the kernel commandline, then try the device tree otherwise
std::string dt_file_name = get_android_dt_dir() + "/boot_devices";
@@ -798,23 +877,6 @@
return ExtraBootDevices(fstab);
}
-FstabEntry BuildGsiSystemFstabEntry() {
- // .logical_partition_name is required to look up AVB Hashtree descriptors.
- FstabEntry system = {
- .blk_device = "system_gsi",
- .mount_point = "/system",
- .fs_type = "ext4",
- .flags = MS_RDONLY,
- .fs_options = "barrier=1",
- // could add more keys separated by ':'.
- .avb_keys = "/avb/q-gsi.avbpubkey:/avb/r-gsi.avbpubkey:/avb/s-gsi.avbpubkey",
- .logical_partition_name = "system"};
- system.fs_mgr_flags.wait = true;
- system.fs_mgr_flags.logical = true;
- system.fs_mgr_flags.first_stage_mount = true;
- return system;
-}
-
std::string GetVerityDeviceName(const FstabEntry& entry) {
std::string base_device;
if (entry.mount_point == "/") {
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index c7193ab..d999ae1 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -101,9 +101,18 @@
bool SkipMountingPartitions(Fstab* fstab);
FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string& path);
+// The Fstab can contain multiple entries for the same mount point with different configurations.
+std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string& path);
-// Helper method to build a GSI fstab entry for mounting /system.
-FstabEntry BuildGsiSystemFstabEntry();
+// This method builds DSU fstab entries and transfer the fstab.
+//
+// fstab points to the unmodified fstab.
+//
+// dsu_partitions contains partition names, e.g.
+// dsu_partitions[0] = "system_gsi"
+// dsu_partitions[1] = "userdata_gsi"
+// dsu_partitions[2] = ...
+void TransformFstabForDsu(Fstab* fstab, const std::vector<std::string>& dsu_partitions);
std::set<std::string> GetBootDevices();
diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index 4cdea71..449a170 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -44,9 +44,24 @@
},
}
-cc_test {
- name: "libdm_test",
- defaults: ["fs_mgr_defaults"],
+filegroup {
+ name: "libdm_test_srcs",
+ srcs: [
+ "dm_test.cpp",
+ "loop_control_test.cpp",
+ "test_util.cpp",
+ ],
+}
+
+cc_defaults {
+ name: "libdm_defaults",
+ sanitize: {
+ misc_undefined: ["integer"],
+ },
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
static_libs: [
"libdm",
"libbase",
@@ -54,9 +69,10 @@
"libfs_mgr",
"liblog",
],
- srcs: [
- "dm_test.cpp",
- "loop_control_test.cpp",
- "test_util.cpp",
- ]
+ srcs: [":libdm_test_srcs"],
+}
+
+cc_test {
+ name: "libdm_test",
+ defaults: ["libdm_defaults"],
}
diff --git a/fs_mgr/libdm/vts_core/Android.bp b/fs_mgr/libdm/vts_core/Android.bp
new file mode 100644
index 0000000..2eceb28
--- /dev/null
+++ b/fs_mgr/libdm/vts_core/Android.bp
@@ -0,0 +1,23 @@
+//
+// 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.
+//
+
+cc_test {
+ name: "vts_libdm_test",
+ defaults: ["libdm_defaults"],
+ test_suites: ["vts-core"],
+ require_root: true,
+ test_min_api_level: 29,
+}
diff --git a/fs_mgr/liblp/Android.bp b/fs_mgr/liblp/Android.bp
index b2572f6..178b343 100644
--- a/fs_mgr/liblp/Android.bp
+++ b/fs_mgr/liblp/Android.bp
@@ -17,7 +17,6 @@
liblp_lib_deps = [
"libbase",
"liblog",
- "libcrypto",
"libcrypto_utils",
"libsparse",
"libext4_utils",
@@ -41,7 +40,9 @@
"utility.cpp",
"writer.cpp",
],
- shared_libs: liblp_lib_deps,
+ shared_libs: [
+ "libcrypto",
+ ] + liblp_lib_deps,
target: {
windows: {
enabled: true,
@@ -55,22 +56,8 @@
export_include_dirs: ["include"],
}
-cc_defaults {
- name: "liblp_test_defaults",
- defaults: ["fs_mgr_defaults"],
- cppflags: [
- "-Wno-unused-parameter",
- ],
- static_libs: [
- "libcutils",
- "libgmock",
- "libfs_mgr",
- "liblp",
- ] + liblp_lib_deps,
- header_libs: [
- "libstorage_literals_headers",
- ],
- stl: "libc++_static",
+filegroup {
+ name: "liblp_test_srcs",
srcs: [
"builder_test.cpp",
"device_test.cpp",
@@ -80,14 +67,37 @@
],
}
+cc_defaults {
+ name: "liblp_test_defaults",
+ sanitize: {
+ misc_undefined: ["integer"],
+ },
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ cppflags: [
+ "-Wno-unused-parameter",
+ ],
+ static_libs: [
+ "libcutils",
+ "libgmock",
+ "libfs_mgr",
+ "liblp",
+ "libcrypto_static",
+ ] + liblp_lib_deps,
+ header_libs: [
+ "libstorage_literals_headers",
+ ],
+ stl: "libc++_static",
+ srcs: [":liblp_test_srcs"],
+}
+
cc_test {
name: "liblp_test",
defaults: ["liblp_test_defaults"],
test_config: "liblp_test.xml",
- test_suites: [
- "device-tests",
- "vts-core",
- ],
+ test_suites: ["device-tests"],
}
cc_test {
diff --git a/fs_mgr/liblp/builder.cpp b/fs_mgr/liblp/builder.cpp
index 96068b1..7405039 100644
--- a/fs_mgr/liblp/builder.cpp
+++ b/fs_mgr/liblp/builder.cpp
@@ -1136,7 +1136,7 @@
return true;
}
-std::vector<Partition*> MetadataBuilder::ListPartitionsInGroup(const std::string& group_name) {
+std::vector<Partition*> MetadataBuilder::ListPartitionsInGroup(std::string_view group_name) {
std::vector<Partition*> partitions;
for (const auto& partition : partitions_) {
if (partition->group_name() == group_name) {
diff --git a/fs_mgr/liblp/include/liblp/builder.h b/fs_mgr/liblp/include/liblp/builder.h
index 4d7f81d..b43ccf0 100644
--- a/fs_mgr/liblp/include/liblp/builder.h
+++ b/fs_mgr/liblp/include/liblp/builder.h
@@ -289,7 +289,7 @@
const std::vector<Interval>& free_region_hint = {});
// Return the list of partitions belonging to a group.
- std::vector<Partition*> ListPartitionsInGroup(const std::string& group_name);
+ std::vector<Partition*> ListPartitionsInGroup(std::string_view group_name);
// Changes a partition's group. Size constraints will not be checked until
// the metadata is exported, to avoid errors during potential group and
diff --git a/fs_mgr/liblp/vts_core/Android.bp b/fs_mgr/liblp/vts_core/Android.bp
new file mode 100644
index 0000000..7af0b9e
--- /dev/null
+++ b/fs_mgr/liblp/vts_core/Android.bp
@@ -0,0 +1,22 @@
+//
+// 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.
+//
+
+cc_test {
+ name: "vts_core_liblp_test",
+ defaults: ["liblp_test_defaults"],
+ test_suites: ["vts-core"],
+ test_min_api_level: 29,
+}
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index bb941dd..834bf3b 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -102,7 +102,7 @@
],
static_libs: [
"libcutils",
- "libcrypto",
+ "libcrypto_static",
"libfs_mgr",
"libgmock",
"liblp",
@@ -114,3 +114,29 @@
"libstorage_literals_headers",
],
}
+
+cc_binary {
+ name: "snapshotctl",
+ srcs: [
+ "snapshotctl.cpp",
+ ],
+ static_libs: [
+ "libdm",
+ "libext2_uuid",
+ "libfiemap_binder",
+ "libfstab",
+ "libsnapshot",
+ ],
+ shared_libs: [
+ "libbase",
+ "libbinder",
+ "libext4_utils",
+ "libfs_mgr",
+ "libutils",
+ "liblog",
+ "liblp",
+ ],
+ init_rc: [
+ "snapshotctl.rc",
+ ],
+}
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index aeeb4aa..0dd275a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -19,6 +19,7 @@
#include <chrono>
#include <map>
#include <memory>
+#include <ostream>
#include <string>
#include <string_view>
#include <vector>
@@ -84,6 +85,7 @@
// operation via fastboot. This state can only be returned by WaitForMerge.
Cancelled
};
+std::ostream& operator<<(std::ostream& os, UpdateState state);
class SnapshotManager final {
using CreateLogicalPartitionParams = android::fs_mgr::CreateLogicalPartitionParams;
@@ -125,8 +127,9 @@
// will fail if GetUpdateState() != None.
bool BeginUpdate();
- // Cancel an update; any snapshots will be deleted. This will fail if the
- // state != Initiated or None.
+ // Cancel an update; any snapshots will be deleted. This is allowed if the
+ // state == Initiated, None, or Unverified (before rebooting to the new
+ // slot).
bool CancelUpdate();
// Mark snapshot writes as having completed. After this, new snapshots cannot
@@ -189,6 +192,9 @@
// call to CreateLogicalPartitions when snapshots are present.
bool CreateLogicalAndSnapshotPartitions(const std::string& super_device);
+ // Dump debug information.
+ bool Dump(std::ostream& os);
+
private:
FRIEND_TEST(SnapshotTest, CleanFirstStageMount);
FRIEND_TEST(SnapshotTest, CreateSnapshot);
@@ -393,6 +399,13 @@
// The reverse of MapPartitionWithSnapshot.
bool UnmapPartitionWithSnapshot(LockedFile* lock, const std::string& target_partition_name);
+ // If there isn't a previous update, return true. |needs_merge| is set to false.
+ // If there is a previous update but the device has not boot into it, tries to cancel the
+ // update and delete any snapshots. Return true if successful. |needs_merge| is set to false.
+ // If there is a previous update and the device has boot into it, do nothing and return true.
+ // |needs_merge| is set to true.
+ bool TryCancelUpdate(bool* needs_merge);
+
std::string gsid_dir_;
std::string metadata_dir_;
std::unique_ptr<IDeviceInfo> device_;
diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index 29d15af..4c9afff 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -18,48 +18,20 @@
#include <liblp/property_fetcher.h>
#include "partition_cow_creator.h"
+#include "test_helpers.h"
using ::android::fs_mgr::MetadataBuilder;
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Return;
namespace android {
namespace snapshot {
-class MockPropertyFetcher : public fs_mgr::IPropertyFetcher {
+class PartitionCowCreatorTest : public ::testing::Test {
public:
- MOCK_METHOD2(GetProperty, std::string(const std::string&, const std::string&));
- MOCK_METHOD2(GetBoolProperty, bool(const std::string&, bool));
+ void SetUp() override { SnapshotTestPropertyFetcher::SetUp(); }
+ void TearDown() override { SnapshotTestPropertyFetcher::TearDown(); }
};
-class PartitionCowCreatorTest : ::testing::Test {
- public:
- void SetUp() override {
- fs_mgr::IPropertyFetcher::OverrideForTesting(std::make_unique<MockPropertyFetcher>());
-
- EXPECT_CALL(fetcher(), GetProperty("ro.boot.slot_suffix", _))
- .Times(AnyNumber())
- .WillRepeatedly(Return("_a"));
- EXPECT_CALL(fetcher(), GetBoolProperty("ro.boot.dynamic_partitions", _))
- .Times(AnyNumber())
- .WillRepeatedly(Return(true));
- EXPECT_CALL(fetcher(), GetBoolProperty("ro.boot.dynamic_partitions_retrofit", _))
- .Times(AnyNumber())
- .WillRepeatedly(Return(false));
- EXPECT_CALL(fetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .Times(AnyNumber())
- .WillRepeatedly(Return(true));
- }
- void TearDown() override {
- fs_mgr::IPropertyFetcher::OverrideForTesting(std::make_unique<MockPropertyFetcher>());
- }
- MockPropertyFetcher& fetcher() {
- return *static_cast<MockPropertyFetcher*>(fs_mgr::IPropertyFetcher::GetInstance());
- }
-};
-
-TEST(PartitionCowCreator, IntersectSelf) {
+TEST_F(PartitionCowCreatorTest, IntersectSelf) {
auto builder_a = MetadataBuilder::New(1024 * 1024, 1024, 2);
ASSERT_NE(builder_a, nullptr);
auto system_a = builder_a->AddPartition("system_a", LP_PARTITION_ATTR_READONLY);
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index b5b3af3..2e689bd 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -131,6 +131,16 @@
}
bool SnapshotManager::BeginUpdate() {
+ bool needs_merge = false;
+ if (!TryCancelUpdate(&needs_merge)) {
+ return false;
+ }
+ if (needs_merge) {
+ LOG(INFO) << "Wait for merge (if any) before beginning a new update.";
+ auto state = ProcessUpdateState();
+ LOG(INFO) << "Merged with state = " << state;
+ }
+
auto file = LockExclusive();
if (!file) return false;
@@ -143,6 +153,19 @@
}
bool SnapshotManager::CancelUpdate() {
+ bool needs_merge = false;
+ if (!TryCancelUpdate(&needs_merge)) {
+ return false;
+ }
+ if (needs_merge) {
+ LOG(ERROR) << "Cannot cancel update after it has completed or started merging";
+ }
+ return !needs_merge;
+}
+
+bool SnapshotManager::TryCancelUpdate(bool* needs_merge) {
+ *needs_merge = false;
+
auto file = LockExclusive();
if (!file) return false;
@@ -167,8 +190,8 @@
return RemoveAllUpdateState(file.get());
}
}
- LOG(ERROR) << "Cannot cancel update after it has completed or started merging";
- return false;
+ *needs_merge = true;
+ return true;
}
bool SnapshotManager::RemoveAllUpdateState(LockedFile* lock) {
@@ -1459,7 +1482,7 @@
PLOG(ERROR) << "Open failed: " << file;
return nullptr;
}
- if (flock(fd, lock_flags) < 0) {
+ if (lock_flags != 0 && flock(fd, lock_flags) < 0) {
PLOG(ERROR) << "Acquire flock failed: " << file;
return nullptr;
}
@@ -1526,34 +1549,33 @@
}
}
-bool SnapshotManager::WriteUpdateState(LockedFile* file, UpdateState state) {
- std::string contents;
+std::ostream& operator<<(std::ostream& os, UpdateState state) {
switch (state) {
case UpdateState::None:
- contents = "none";
- break;
+ return os << "none";
case UpdateState::Initiated:
- contents = "initiated";
- break;
+ return os << "initiated";
case UpdateState::Unverified:
- contents = "unverified";
- break;
+ return os << "unverified";
case UpdateState::Merging:
- contents = "merging";
- break;
+ return os << "merging";
case UpdateState::MergeCompleted:
- contents = "merge-completed";
- break;
+ return os << "merge-completed";
case UpdateState::MergeNeedsReboot:
- contents = "merge-needs-reboot";
- break;
+ return os << "merge-needs-reboot";
case UpdateState::MergeFailed:
- contents = "merge-failed";
- break;
+ return os << "merge-failed";
default:
LOG(ERROR) << "Unknown update state";
- return false;
+ return os;
}
+}
+
+bool SnapshotManager::WriteUpdateState(LockedFile* file, UpdateState state) {
+ std::stringstream ss;
+ ss << state;
+ std::string contents = ss.str();
+ if (contents.empty()) return false;
if (!Truncate(file)) return false;
if (!android::base::WriteStringToFd(contents, file->fd())) {
@@ -1719,6 +1741,22 @@
return true;
}
+static void UnmapAndDeleteCowPartition(MetadataBuilder* current_metadata) {
+ auto& dm = DeviceMapper::Instance();
+ std::vector<std::string> to_delete;
+ for (auto* existing_cow_partition : current_metadata->ListPartitionsInGroup(kCowGroupName)) {
+ if (!dm.DeleteDeviceIfExists(existing_cow_partition->name())) {
+ LOG(WARNING) << existing_cow_partition->name()
+ << " cannot be unmapped and its space cannot be reclaimed";
+ continue;
+ }
+ to_delete.push_back(existing_cow_partition->name());
+ }
+ for (const auto& name : to_delete) {
+ current_metadata->RemovePartition(name);
+ }
+}
+
bool SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manifest) {
auto lock = LockExclusive();
if (!lock) return false;
@@ -1766,6 +1804,10 @@
return false;
}
+ // Delete previous COW partitions in current_metadata so that PartitionCowCreator marks those as
+ // free regions.
+ UnmapAndDeleteCowPartition(current_metadata.get());
+
// Check that all these metadata is not retrofit dynamic partitions. Snapshots on
// devices with retrofit dynamic partitions does not make sense.
// This ensures that current_metadata->GetFreeRegions() uses the same device
@@ -1940,5 +1982,47 @@
return UnmapPartitionWithSnapshot(lock.get(), target_partition_name);
}
+bool SnapshotManager::Dump(std::ostream& os) {
+ // Don't actually lock. Dump() is for debugging purposes only, so it is okay
+ // if it is racy.
+ auto file = OpenStateFile(O_RDONLY, 0);
+ if (!file) return false;
+
+ std::stringstream ss;
+
+ ss << "Update state: " << ReadUpdateState(file.get()) << std::endl;
+
+ auto boot_file = GetSnapshotBootIndicatorPath();
+ std::string boot_indicator;
+ if (android::base::ReadFileToString(boot_file, &boot_indicator)) {
+ ss << "Boot indicator: old slot = " << boot_indicator << std::endl;
+ }
+
+ bool ok = true;
+ std::vector<std::string> snapshots;
+ if (!ListSnapshots(file.get(), &snapshots)) {
+ LOG(ERROR) << "Could not list snapshots";
+ snapshots.clear();
+ ok = false;
+ }
+ for (const auto& name : snapshots) {
+ ss << "Snapshot: " << name << std::endl;
+ SnapshotStatus status;
+ if (!ReadSnapshotStatus(file.get(), name, &status)) {
+ ok = false;
+ continue;
+ }
+ ss << " state: " << to_string(status.state) << std::endl;
+ ss << " device size (bytes): " << status.device_size << std::endl;
+ ss << " snapshot size (bytes): " << status.snapshot_size << std::endl;
+ ss << " cow partition size (bytes): " << status.cow_partition_size << std::endl;
+ ss << " cow file size (bytes): " << status.cow_file_size << std::endl;
+ ss << " allocated sectors: " << status.sectors_allocated << std::endl;
+ ss << " metadata sectors: " << status.metadata_sectors << std::endl;
+ }
+ os << ss.rdbuf();
+ return ok;
+}
+
} // namespace snapshot
} // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_metadata_updater_test.cpp b/fs_mgr/libsnapshot/snapshot_metadata_updater_test.cpp
index 535653a..7d96a67 100644
--- a/fs_mgr/libsnapshot/snapshot_metadata_updater_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_metadata_updater_test.cpp
@@ -45,6 +45,7 @@
void SetUp() override {
target_slot_ = GetParam();
target_suffix_ = SlotSuffixForSlotNumber(target_slot_);
+ SnapshotTestPropertyFetcher::SetUp(SlotSuffixForSlotNumber(1 - target_slot_));
builder_ = MetadataBuilder::New(4_GiB + 1_MiB, 4_KiB, 2);
group_ = manifest_.mutable_dynamic_partition_metadata()->add_groups();
@@ -62,6 +63,8 @@
ASSERT_TRUE(FillFakeMetadata(builder_.get(), manifest_, target_suffix_));
}
+ void TearDown() override { SnapshotTestPropertyFetcher::TearDown(); }
+
// Append suffix to name.
std::string T(std::string_view name) { return std::string(name) + target_suffix_; }
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 36982a9..c94fde5 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -31,7 +31,6 @@
#include <libdm/dm.h>
#include <libfiemap/image_manager.h>
#include <liblp/builder.h>
-#include <liblp/mock_property_fetcher.h>
#include <storage_literals/storage_literals.h>
#include "test_helpers.h"
@@ -47,13 +46,14 @@
using android::fs_mgr::BlockDeviceInfo;
using android::fs_mgr::CreateLogicalPartitionParams;
using android::fs_mgr::DestroyLogicalPartition;
+using android::fs_mgr::Extent;
using android::fs_mgr::GetPartitionGroupName;
using android::fs_mgr::GetPartitionName;
+using android::fs_mgr::Interval;
using android::fs_mgr::MetadataBuilder;
using chromeos_update_engine::DeltaArchiveManifest;
using chromeos_update_engine::PartitionUpdate;
using namespace ::testing;
-using namespace android::fs_mgr::testing;
using namespace android::storage_literals;
using namespace std::chrono_literals;
using namespace std::string_literals;
@@ -79,7 +79,7 @@
protected:
void SetUp() override {
- ResetMockPropertyFetcher();
+ SnapshotTestPropertyFetcher::SetUp();
InitializeState();
CleanupTestArtifacts();
FormatFakeSuper();
@@ -91,7 +91,7 @@
lock_ = nullptr;
CleanupTestArtifacts();
- ResetMockPropertyFetcher();
+ SnapshotTestPropertyFetcher::TearDown();
}
void InitializeState() {
@@ -373,9 +373,6 @@
}
TEST_F(SnapshotTest, Merge) {
- ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .WillByDefault(Return(true));
-
ASSERT_TRUE(AcquireLock());
static const uint64_t kDeviceSize = 1024 * 1024;
@@ -493,9 +490,6 @@
}
TEST_F(SnapshotTest, FirstStageMountAndMerge) {
- ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .WillByDefault(Return(true));
-
ASSERT_TRUE(AcquireLock());
static const uint64_t kDeviceSize = 1024 * 1024;
@@ -513,10 +507,7 @@
ASSERT_TRUE(sm->FinishedSnapshotWrites());
ASSERT_TRUE(DestroyLogicalPartition("test_partition_b-base"));
- auto rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_b");
-
- auto init = SnapshotManager::NewForFirstStageMount(rebooted);
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
ASSERT_NE(init, nullptr);
ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -535,9 +526,6 @@
}
TEST_F(SnapshotTest, FlashSuperDuringUpdate) {
- ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .WillByDefault(Return(true));
-
ASSERT_TRUE(AcquireLock());
static const uint64_t kDeviceSize = 1024 * 1024;
@@ -559,10 +547,7 @@
FormatFakeSuper();
ASSERT_TRUE(CreatePartition("test_partition_b", kDeviceSize));
- auto rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_b");
-
- auto init = SnapshotManager::NewForFirstStageMount(rebooted);
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
ASSERT_NE(init, nullptr);
ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -583,9 +568,6 @@
}
TEST_F(SnapshotTest, FlashSuperDuringMerge) {
- ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .WillByDefault(Return(true));
-
ASSERT_TRUE(AcquireLock());
static const uint64_t kDeviceSize = 1024 * 1024;
@@ -603,10 +585,7 @@
ASSERT_TRUE(sm->FinishedSnapshotWrites());
ASSERT_TRUE(DestroyLogicalPartition("test_partition_b-base"));
- auto rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_b");
-
- auto init = SnapshotManager::NewForFirstStageMount(rebooted);
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
ASSERT_NE(init, nullptr);
ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -636,9 +615,6 @@
// Cleanup() changes slot suffix, so initialize it again.
test_device->set_slot_suffix("_a");
- ON_CALL(*GetMockedPropertyFetcher(), GetBoolProperty("ro.virtual_ab.enabled", _))
- .WillByDefault(Return(true));
-
opener_ = std::make_unique<TestPartitionOpener>(fake_super);
// Create a fake update package metadata.
@@ -761,10 +737,6 @@
// Also test UnmapUpdateSnapshot unmaps everything.
// Also test first stage mount and merge after this.
TEST_F(SnapshotUpdateTest, FullUpdateFlow) {
- // OTA client calls CancelUpdate then BeginUpdate before doing anything.
- ASSERT_TRUE(sm->CancelUpdate());
- ASSERT_TRUE(sm->BeginUpdate());
-
// OTA client blindly unmaps all partitions that are possibly mapped.
for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
ASSERT_TRUE(sm->UnmapUpdateSnapshot(name));
@@ -775,6 +747,8 @@
SetSize(vnd_, 4_MiB);
SetSize(prd_, 4_MiB);
+ // Execute the update.
+ ASSERT_TRUE(sm->BeginUpdate());
ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
// Test that partitions prioritize using space in super.
@@ -813,9 +787,7 @@
ASSERT_TRUE(UnmapAll());
// After reboot, init does first stage mount.
- auto rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_b");
- auto init = SnapshotManager::NewForFirstStageMount(rebooted);
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
ASSERT_NE(init, nullptr);
ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -966,9 +938,7 @@
ASSERT_TRUE(UnmapAll());
// After reboot, init does first stage mount.
- auto rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_b");
- auto init = SnapshotManager::NewForFirstStageMount(rebooted);
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
ASSERT_NE(init, nullptr);
ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -980,9 +950,7 @@
// Simulate shutting down the device again.
ASSERT_TRUE(UnmapAll());
- rebooted = new TestDeviceInfo(fake_super);
- rebooted->set_slot_suffix("_a");
- init = SnapshotManager::NewForFirstStageMount(rebooted);
+ init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_a"));
ASSERT_NE(init, nullptr);
ASSERT_FALSE(init->NeedSnapshotsInFirstStageMount());
ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
@@ -1000,6 +968,57 @@
ASSERT_TRUE(sm->CancelUpdate());
}
+static std::vector<Interval> ToIntervals(const std::vector<std::unique_ptr<Extent>>& extents) {
+ std::vector<Interval> ret;
+ std::transform(extents.begin(), extents.end(), std::back_inserter(ret),
+ [](const auto& extent) { return extent->AsLinearExtent()->AsInterval(); });
+ return ret;
+}
+
+// Test that at the second update, old COW partition spaces are reclaimed.
+TEST_F(SnapshotUpdateTest, ReclaimCow) {
+ // Execute the first update.
+ ASSERT_TRUE(sm->BeginUpdate());
+ ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
+ ASSERT_TRUE(sm->FinishedSnapshotWrites());
+
+ // Simulate shutting down the device.
+ ASSERT_TRUE(UnmapAll());
+
+ // After reboot, init does first stage mount.
+ auto init = SnapshotManager::NewForFirstStageMount(new TestDeviceInfo(fake_super, "_b"));
+ ASSERT_NE(init, nullptr);
+ ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
+ ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super"));
+ init = nullptr;
+
+ // Initiate the merge and wait for it to be completed.
+ auto new_sm = SnapshotManager::New(new TestDeviceInfo(fake_super, "_b"));
+ ASSERT_TRUE(new_sm->InitiateMerge());
+ ASSERT_EQ(UpdateState::MergeCompleted, new_sm->ProcessUpdateState());
+
+ // Execute the second update.
+ ASSERT_TRUE(new_sm->BeginUpdate());
+ ASSERT_TRUE(new_sm->CreateUpdateSnapshots(manifest_));
+
+ // Check that the old COW space is reclaimed and does not occupy space of mapped partitions.
+ auto src = MetadataBuilder::New(*opener_, "super", 1);
+ auto tgt = MetadataBuilder::New(*opener_, "super", 0);
+ for (const auto& cow_part_name : {"sys_a-cow", "vnd_a-cow", "prd_a-cow"}) {
+ auto* cow_part = tgt->FindPartition(cow_part_name);
+ ASSERT_NE(nullptr, cow_part) << cow_part_name << " does not exist in target metadata";
+ auto cow_intervals = ToIntervals(cow_part->extents());
+ for (const auto& old_part_name : {"sys_b", "vnd_b", "prd_b"}) {
+ auto* old_part = src->FindPartition(old_part_name);
+ ASSERT_NE(nullptr, old_part) << old_part_name << " does not exist in source metadata";
+ auto old_intervals = ToIntervals(old_part->extents());
+
+ auto intersect = Interval::Intersect(cow_intervals, old_intervals);
+ ASSERT_TRUE(intersect.empty()) << "COW uses space of source partitions";
+ }
+ }
+}
+
} // namespace snapshot
} // namespace android
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
new file mode 100644
index 0000000..d65320c
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -0,0 +1,115 @@
+//
+// 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 <sysexits.h>
+
+#include <chrono>
+#include <iostream>
+#include <map>
+
+#include <android-base/logging.h>
+#include <libsnapshot/snapshot.h>
+
+using namespace std::string_literals;
+
+int Usage() {
+ std::cerr << "snapshotctl: Control snapshots.\n"
+ "Usage: snapshotctl [action] [flags]\n"
+ "Actions:\n"
+ " dump\n"
+ " Print snapshot states.\n"
+ " merge [--logcat]\n"
+ " Initialize merge and wait for it to be completed.\n"
+ " If --logcat is specified, log to logcat. Otherwise, log to stdout.\n";
+ return EX_USAGE;
+}
+
+namespace android {
+namespace snapshot {
+
+bool DumpCmdHandler(int /*argc*/, char** argv) {
+ android::base::InitLogging(argv, &android::base::StderrLogger);
+ return SnapshotManager::New()->Dump(std::cout);
+}
+
+bool MergeCmdHandler(int argc, char** argv) {
+ auto begin = std::chrono::steady_clock::now();
+
+ bool log_to_logcat = false;
+ for (int i = 2; i < argc; ++i) {
+ if (argv[i] == "--logcat"s) {
+ log_to_logcat = true;
+ }
+ }
+ if (log_to_logcat) {
+ android::base::InitLogging(argv);
+ } else {
+ android::base::InitLogging(argv, &android::base::StdioLogger);
+ }
+
+ auto sm = SnapshotManager::New();
+
+ auto state = sm->GetUpdateState();
+ if (state == UpdateState::None) {
+ LOG(INFO) << "Can't find any snapshot to merge.";
+ return true;
+ }
+ if (state == UpdateState::Unverified) {
+ if (!sm->InitiateMerge()) {
+ LOG(ERROR) << "Failed to initiate merge.";
+ return false;
+ }
+ }
+
+ // All other states can be handled by ProcessUpdateState.
+ LOG(INFO) << "Waiting for any merge to complete. This can take up to 1 minute.";
+ state = SnapshotManager::New()->ProcessUpdateState();
+
+ if (state == UpdateState::MergeCompleted) {
+ auto end = std::chrono::steady_clock::now();
+ auto passed = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+ LOG(INFO) << "Snapshot merged in " << passed << " ms.";
+ return true;
+ }
+
+ LOG(ERROR) << "Snapshot failed to merge with state \"" << state << "\".";
+ return false;
+}
+
+static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
+ // clang-format off
+ {"dump", DumpCmdHandler},
+ {"merge", MergeCmdHandler},
+ // clang-format on
+};
+
+} // namespace snapshot
+} // namespace android
+
+int main(int argc, char** argv) {
+ using namespace android::snapshot;
+ if (argc < 2) {
+ return Usage();
+ }
+
+ for (const auto& cmd : kCmdMap) {
+ if (cmd.first == argv[1]) {
+ return cmd.second(argc, argv) ? EX_OK : EX_SOFTWARE;
+ }
+ }
+
+ return Usage();
+}
diff --git a/fs_mgr/libsnapshot/snapshotctl.rc b/fs_mgr/libsnapshot/snapshotctl.rc
new file mode 100644
index 0000000..29707f1
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapshotctl.rc
@@ -0,0 +1,2 @@
+on property:sys.boot_completed=1
+ exec - root root -- /system/bin/snapshotctl merge --logcat
diff --git a/fs_mgr/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/test_helpers.h
index 0303a14..bb19adc 100644
--- a/fs_mgr/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/test_helpers.h
@@ -17,8 +17,10 @@
#include <optional>
#include <string>
+#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <libfiemap/image_manager.h>
+#include <liblp/mock_property_fetcher.h>
#include <liblp/partition_opener.h>
#include <libsnapshot/snapshot.h>
#include <update_engine/update_metadata.pb.h>
@@ -26,10 +28,15 @@
namespace android {
namespace snapshot {
+using android::fs_mgr::IPropertyFetcher;
using android::fs_mgr::MetadataBuilder;
+using android::fs_mgr::testing::MockPropertyFetcher;
using chromeos_update_engine::DeltaArchiveManifest;
using chromeos_update_engine::PartitionUpdate;
+using testing::_;
using testing::AssertionResult;
+using testing::NiceMock;
+using testing::Return;
using namespace std::string_literals;
@@ -52,6 +59,10 @@
public:
TestDeviceInfo() {}
explicit TestDeviceInfo(const std::string& fake_super) { set_fake_super(fake_super); }
+ TestDeviceInfo(const std::string& fake_super, const std::string& slot_suffix)
+ : TestDeviceInfo(fake_super) {
+ set_slot_suffix(slot_suffix);
+ }
std::string GetGsidDir() const override { return "ota/test"s; }
std::string GetMetadataDir() const override { return "/metadata/ota/test"s; }
std::string GetSlotSuffix() const override { return slot_suffix_; }
@@ -72,6 +83,28 @@
std::unique_ptr<TestPartitionOpener> opener_;
};
+class SnapshotTestPropertyFetcher : public android::fs_mgr::testing::MockPropertyFetcher {
+ public:
+ SnapshotTestPropertyFetcher(const std::string& slot_suffix) {
+ ON_CALL(*this, GetProperty("ro.boot.slot_suffix", _)).WillByDefault(Return(slot_suffix));
+ ON_CALL(*this, GetBoolProperty("ro.boot.dynamic_partitions", _))
+ .WillByDefault(Return(true));
+ ON_CALL(*this, GetBoolProperty("ro.boot.dynamic_partitions_retrofit", _))
+ .WillByDefault(Return(false));
+ ON_CALL(*this, GetBoolProperty("ro.virtual_ab.enabled", _)).WillByDefault(Return(true));
+ }
+
+ static void SetUp(const std::string& slot_suffix = "_a") { Reset(slot_suffix); }
+
+ static void TearDown() { Reset("_a"); }
+
+ private:
+ static void Reset(const std::string& slot_suffix) {
+ IPropertyFetcher::OverrideForTesting(
+ std::make_unique<NiceMock<SnapshotTestPropertyFetcher>>(slot_suffix));
+ }
+};
+
// Helper for error-spam-free cleanup.
void DeleteBackingImage(android::fiemap::IImageManager* manager, const std::string& name);
diff --git a/init/Android.mk b/init/Android.mk
index 8f58437..62e452f 100644
--- a/init/Android.mk
+++ b/init/Android.mk
@@ -100,7 +100,7 @@
libcutils \
libbase \
liblog \
- libcrypto \
+ libcrypto_static \
libdl \
libz \
libselinux \
@@ -108,7 +108,7 @@
libgsi \
libcom.android.sysprop.apex \
liblzma \
- libdexfile_support \
+ libdexfile_support_static \
libunwindstack \
libbacktrace \
libmodprobe \
@@ -118,7 +118,6 @@
LOCAL_SANITIZE := signed-integer-overflow
# First stage init is weird: it may start without stdout/stderr, and no /proc.
LOCAL_NOSANITIZE := hwaddress
-LOCAL_INJECT_BSSL_HASH := true
include $(BUILD_EXECUTABLE)
endif
diff --git a/init/README.md b/init/README.md
index 423c6d1..29b972d 100644
--- a/init/README.md
+++ b/init/README.md
@@ -170,6 +170,8 @@
be changed by setting the "androidboot.console" kernel parameter. In
all cases the leading "/dev/" should be omitted, so "/dev/tty0" would be
specified as just "console tty0".
+ This option connects stdin, stdout, and stderr to the console. It is mutually exclusive with the
+ stdio_to_kmsg option, which only connects stdout and stderr to kmsg.
`critical`
> This is a device-critical service. If it exits more than four times in
@@ -313,6 +315,13 @@
seclabel or computed based on the service executable file security context.
For native executables see libcutils android\_get\_control\_socket().
+`stdio_to_kmsg`
+> Redirect stdout and stderr to /dev/kmsg_debug. This is useful for services that do not use native
+ Android logging during early boot and whose logs messages we want to capture. This is only enabled
+ when /dev/kmsg_debug is enabled, which is only enabled on userdebug and eng builds.
+ This is mutually exclusive with the console option, which additionally connects stdin to the
+ given console.
+
`timeout_period <seconds>`
> Provide a timeout after which point the service will be killed. The oneshot keyword is respected
here, so oneshot services do not automatically restart, however all other services will.
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 4a1bc5a..9121bac 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -50,12 +50,13 @@
using android::fs_mgr::AvbHandleStatus;
using android::fs_mgr::AvbHashtreeResult;
using android::fs_mgr::AvbUniquePtr;
-using android::fs_mgr::BuildGsiSystemFstabEntry;
using android::fs_mgr::Fstab;
using android::fs_mgr::FstabEntry;
using android::fs_mgr::ReadDefaultFstab;
using android::fs_mgr::ReadFstabFromDt;
using android::fs_mgr::SkipMountingPartitions;
+using android::fs_mgr::TransformFstabForDsu;
+using android::init::WriteFile;
using android::snapshot::SnapshotManager;
using namespace std::literals;
@@ -596,14 +597,14 @@
}
void FirstStageMount::UseGsiIfPresent() {
- std::string metadata_file, error;
+ std::string error;
- if (!android::gsi::CanBootIntoGsi(&metadata_file, &error)) {
+ if (!android::gsi::CanBootIntoGsi(&error)) {
LOG(INFO) << "GSI " << error << ", proceeding with normal boot";
return;
}
- auto metadata = android::fs_mgr::ReadFromImageFile(metadata_file.c_str());
+ auto metadata = android::fs_mgr::ReadFromImageFile(gsi::kDsuLpMetadataFile);
if (!metadata) {
LOG(ERROR) << "GSI partition layout could not be read";
return;
@@ -627,14 +628,16 @@
return;
}
- // Replace the existing system fstab entry.
- auto system_partition = std::find_if(fstab_.begin(), fstab_.end(), [](const auto& entry) {
- return entry.mount_point == "/system";
- });
- if (system_partition != fstab_.end()) {
- fstab_.erase(system_partition);
+ std::string lp_names = "";
+ std::vector<std::string> dsu_partitions;
+ for (auto&& partition : metadata->partitions) {
+ auto name = fs_mgr::GetPartitionName(partition);
+ dsu_partitions.push_back(name);
+ lp_names += name + ",";
}
- fstab_.emplace_back(BuildGsiSystemFstabEntry());
+ // Publish the logical partition names for TransformFstabForDsu
+ WriteFile(gsi::kGsiLpNamesFile, lp_names);
+ TransformFstabForDsu(&fstab_, dsu_partitions);
gsi_not_on_userdata_ = (super_name != "userdata");
}
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 45d1852..e7808a9 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -83,6 +83,9 @@
}
Result<void> ServiceParser::ParseConsole(std::vector<std::string>&& args) {
+ if (service_->proc_attr_.stdio_to_kmsg) {
+ return Error() << "'console' and 'stdio_to_kmsg' are mutually exclusive";
+ }
service_->flags_ |= SVC_CONSOLE;
service_->proc_attr_.console = args.size() > 1 ? "/dev/" + args[1] : "";
return {};
@@ -429,6 +432,14 @@
return {};
}
+Result<void> ServiceParser::ParseStdioToKmsg(std::vector<std::string>&& args) {
+ if (service_->flags_ & SVC_CONSOLE) {
+ return Error() << "'stdio_to_kmsg' and 'console' are mutually exclusive";
+ }
+ service_->proc_attr_.stdio_to_kmsg = true;
+ return {};
+}
+
// name type
Result<void> ServiceParser::ParseFile(std::vector<std::string>&& args) {
if (args[2] != "r" && args[2] != "w" && args[2] != "rw") {
@@ -514,6 +525,7 @@
{"shutdown", {1, 1, &ServiceParser::ParseShutdown}},
{"sigstop", {0, 0, &ServiceParser::ParseSigstop}},
{"socket", {3, 6, &ServiceParser::ParseSocket}},
+ {"stdio_to_kmsg", {0, 0, &ServiceParser::ParseStdioToKmsg}},
{"timeout_period", {1, 1, &ServiceParser::ParseTimeoutPeriod}},
{"updatable", {0, 0, &ServiceParser::ParseUpdatable}},
{"user", {1, 1, &ServiceParser::ParseUser}},
diff --git a/init/service_parser.h b/init/service_parser.h
index f063102..b1281f5 100644
--- a/init/service_parser.h
+++ b/init/service_parser.h
@@ -75,6 +75,7 @@
Result<void> ParseShutdown(std::vector<std::string>&& args);
Result<void> ParseSigstop(std::vector<std::string>&& args);
Result<void> ParseSocket(std::vector<std::string>&& args);
+ Result<void> ParseStdioToKmsg(std::vector<std::string>&& args);
Result<void> ParseTimeoutPeriod(std::vector<std::string>&& args);
Result<void> ParseFile(std::vector<std::string>&& args);
Result<void> ParseUser(std::vector<std::string>&& args);
diff --git a/init/service_utils.cpp b/init/service_utils.cpp
index 35f2acf..93cffd8 100644
--- a/init/service_utils.cpp
+++ b/init/service_utils.cpp
@@ -16,10 +16,12 @@
#include "service_utils.h"
+#include <fcntl.h>
#include <grp.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/wait.h>
+#include <unistd.h>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -121,11 +123,15 @@
return {};
}
-void ZapStdio() {
+void SetupStdio(bool stdio_to_kmsg) {
auto fd = unique_fd{open("/dev/null", O_RDWR | O_CLOEXEC)};
- dup2(fd, 0);
- dup2(fd, 1);
- dup2(fd, 2);
+ dup2(fd, STDIN_FILENO);
+ if (stdio_to_kmsg) {
+ fd.reset(open("/dev/kmsg_debug", O_WRONLY | O_CLOEXEC));
+ if (fd == -1) fd.reset(open("/dev/null", O_WRONLY | O_CLOEXEC));
+ }
+ dup2(fd, STDOUT_FILENO);
+ dup2(fd, STDERR_FILENO);
}
void OpenConsole(const std::string& console) {
@@ -238,7 +244,7 @@
if (setpgid(0, getpid()) == -1) {
return ErrnoError() << "setpgid failed";
}
- ZapStdio();
+ SetupStdio(attr.stdio_to_kmsg);
}
for (const auto& rlimit : attr.rlimits) {
diff --git a/init/service_utils.h b/init/service_utils.h
index d2e69d9..3f1071e 100644
--- a/init/service_utils.h
+++ b/init/service_utils.h
@@ -77,6 +77,7 @@
gid_t gid;
std::vector<gid_t> supp_gids;
int priority;
+ bool stdio_to_kmsg;
};
Result<void> SetProcessAttributes(const ProcessAttributes& attr);
diff --git a/init/uevent_listener.cpp b/init/uevent_listener.cpp
index ac633776..416d942 100644
--- a/init/uevent_listener.cpp
+++ b/init/uevent_listener.cpp
@@ -171,7 +171,7 @@
return RegenerateUeventsForDir(d.get(), callback);
}
-static const char* kRegenerationPaths[] = {"/sys/class", "/sys/block", "/sys/devices"};
+static const char* kRegenerationPaths[] = {"/sys/devices"};
void UeventListener::RegenerateUevents(const ListenerCallback& callback) const {
for (const auto path : kRegenerationPaths) {
diff --git a/libpackagelistparser/Android.bp b/libpackagelistparser/Android.bp
index 0740e7d..b56dcdb 100644
--- a/libpackagelistparser/Android.bp
+++ b/libpackagelistparser/Android.bp
@@ -19,4 +19,5 @@
"libpackagelistparser",
],
test_suites: ["device-tests"],
+ require_root: true,
}
diff --git a/libsparse/Android.bp b/libsparse/Android.bp
index 2ec4754..88146e9 100644
--- a/libsparse/Android.bp
+++ b/libsparse/Android.bp
@@ -82,3 +82,15 @@
},
},
}
+
+cc_fuzz {
+ name: "sparse_fuzzer",
+ host_supported: false,
+ srcs: [
+ "sparse_fuzzer.cpp",
+ ],
+ static_libs: [
+ "libsparse",
+ "liblog",
+ ],
+}
diff --git a/libsparse/sparse_fuzzer.cpp b/libsparse/sparse_fuzzer.cpp
new file mode 100644
index 0000000..42f331f
--- /dev/null
+++ b/libsparse/sparse_fuzzer.cpp
@@ -0,0 +1,16 @@
+#include "include/sparse/sparse.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ if (size < 2 * sizeof(wchar_t)) return 0;
+
+ int64_t blocksize = 4096;
+ struct sparse_file* file = sparse_file_new(size, blocksize);
+ if (!file) {
+ return 0;
+ }
+
+ unsigned int block = 1;
+ sparse_file_add_data(file, &data, size, block);
+ sparse_file_destroy(file);
+ return 0;
+}
diff --git a/libutils/include/utils/Trace.h b/libutils/include/utils/Trace.h
index 4b9c91e..fec0ffa 100644
--- a/libutils/include/utils/Trace.h
+++ b/libutils/include/utils/Trace.h
@@ -17,7 +17,12 @@
#ifndef ANDROID_TRACE_H
#define ANDROID_TRACE_H
-#if defined(__ANDROID__)
+#if defined(_WIN32)
+
+#define ATRACE_NAME(...)
+#define ATRACE_CALL()
+
+#else // !_WIN32
#include <stdint.h>
@@ -51,11 +56,6 @@
} // namespace android
-#else // !__ANDROID__
-
-#define ATRACE_NAME(...)
-#define ATRACE_CALL()
-
-#endif // __ANDROID__
+#endif // _WIN32
#endif // ANDROID_TRACE_H
diff --git a/logd/LogAudit.cpp b/logd/LogAudit.cpp
index 5a375ec..665bd38 100644
--- a/logd/LogAudit.cpp
+++ b/logd/LogAudit.cpp
@@ -160,7 +160,7 @@
}
auto search = denial_to_bug.find(scontext + tcontext + tclass);
if (search != denial_to_bug.end()) {
- bug_num->assign(" b/" + search->second);
+ bug_num->assign(" " + search->second);
} else {
bug_num->assign("");
}
diff --git a/logd/tests/logd_test.cpp b/logd/tests/logd_test.cpp
index b6c33d7..80625a7 100644
--- a/logd/tests/logd_test.cpp
+++ b/logd/tests/logd_test.cpp
@@ -349,86 +349,6 @@
}
#endif
-TEST(logd, both) {
-#ifdef __ANDROID__
- log_msg msg;
-
- // check if we can read any logs from logd
- bool user_logger_available = false;
- bool user_logger_content = false;
-
- int fd = socket_local_client("logdr", ANDROID_SOCKET_NAMESPACE_RESERVED,
- SOCK_SEQPACKET);
- if (fd >= 0) {
- struct sigaction ignore, old_sigaction;
- memset(&ignore, 0, sizeof(ignore));
- ignore.sa_handler = caught_signal;
- sigemptyset(&ignore.sa_mask);
- sigaction(SIGALRM, &ignore, &old_sigaction);
- unsigned int old_alarm = alarm(10);
-
- static const char ask[] = "dumpAndClose lids=0,1,2,3";
- user_logger_available = write(fd, ask, sizeof(ask)) == sizeof(ask);
-
- user_logger_content = recv(fd, msg.buf, sizeof(msg), 0) > 0;
-
- if (user_logger_content) {
- dump_log_msg("user", &msg, 3, -1);
- }
-
- alarm(old_alarm);
- sigaction(SIGALRM, &old_sigaction, nullptr);
-
- close(fd);
- }
-
- // check if we can read any logs from kernel logger
- bool kernel_logger_available = false;
- bool kernel_logger_content = false;
-
- static const char* loggers[] = {
- "/dev/log/main", "/dev/log_main", "/dev/log/radio",
- "/dev/log_radio", "/dev/log/events", "/dev/log_events",
- "/dev/log/system", "/dev/log_system",
- };
-
- for (unsigned int i = 0; i < arraysize(loggers); ++i) {
- fd = open(loggers[i], O_RDONLY);
- if (fd < 0) {
- continue;
- }
- kernel_logger_available = true;
- fcntl(fd, F_SETFL, O_RDONLY | O_NONBLOCK);
- int result = TEMP_FAILURE_RETRY(read(fd, msg.buf, sizeof(msg)));
- if (result > 0) {
- kernel_logger_content = true;
- dump_log_msg("kernel", &msg, 0, i / 2);
- }
- close(fd);
- }
-
- static const char yes[] = "\xE2\x9C\x93";
- static const char no[] = "\xE2\x9c\x98";
- fprintf(stderr,
- "LOGGER Available Content\n"
- "user %-13s%s\n"
- "kernel %-13s%s\n"
- " status %-11s%s\n",
- (user_logger_available) ? yes : no, (user_logger_content) ? yes : no,
- (kernel_logger_available) ? yes : no,
- (kernel_logger_content) ? yes : no,
- (user_logger_available && kernel_logger_available) ? "ERROR" : "ok",
- (user_logger_content && kernel_logger_content) ? "ERROR" : "ok");
-
- EXPECT_EQ(0, user_logger_available && kernel_logger_available);
- EXPECT_EQ(0, !user_logger_available && !kernel_logger_available);
- EXPECT_EQ(0, user_logger_content && kernel_logger_content);
- EXPECT_EQ(0, !user_logger_content && !kernel_logger_content);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
-}
-
#ifdef __ANDROID__
// BAD ROBOT
// Benchmark threshold are generally considered bad form unless there is
diff --git a/logwrapper/include/logwrap/logwrap.h b/logwrapper/include/logwrap/logwrap.h
index d3538b3..b1f6410 100644
--- a/logwrapper/include/logwrap/logwrap.h
+++ b/logwrapper/include/logwrap/logwrap.h
@@ -15,8 +15,7 @@
* limitations under the License.
*/
-#ifndef __LIBS_LOGWRAP_H
-#define __LIBS_LOGWRAP_H
+#pragma once
#include <stdbool.h>
#include <stdint.h>
@@ -26,12 +25,6 @@
/*
* Run a command while logging its stdout and stderr
*
- * WARNING: while this function is running it will clear all SIGCHLD handlers
- * if you rely on SIGCHLD in the caller there is a chance zombies will be
- * created if you're not calling waitpid after calling this. This function will
- * log a warning when it clears SIGCHLD for processes other than the child it
- * created.
- *
* Arguments:
* argc: the number of elements in argv
* argv: an array of strings containing the command to be executed and its
@@ -40,10 +33,10 @@
* status: the equivalent child status as populated by wait(status). This
* value is only valid when logwrap successfully completes. If NULL
* the return value of the child will be the function's return value.
- * ignore_int_quit: set to true if you want to completely ignore SIGINT and
- * SIGQUIT while logwrap is running. This may force the end-user to
- * send a signal twice to signal the caller (once for the child, and
- * once for the caller)
+ * forward_signals: set to true if you want to forward SIGINT, SIGQUIT, and
+ * SIGHUP to the child process, while it is running. You likely do
+ * not need to use this; it is primarily for the logwrapper
+ * executable itself.
* log_target: Specify where to log the output of the child, either LOG_NONE,
* LOG_ALOG (for the Android system log), LOG_KLOG (for the kernel
* log), or LOG_FILE (and you need to specify a pathname in the
@@ -54,8 +47,6 @@
* the specified log until the child has exited.
* file_path: if log_target has the LOG_FILE bit set, then this parameter
* must be set to the pathname of the file to log to.
- * unused_opts: currently unused.
- * unused_opts_len: currently unused.
*
* Return value:
* 0 when logwrap successfully run the child process and captured its status
@@ -71,10 +62,18 @@
#define LOG_KLOG 2
#define LOG_FILE 4
-// TODO: Remove unused_opts / unused_opts_len in a followup change.
-int android_fork_execvp_ext(int argc, char* argv[], int *status, bool ignore_int_quit,
- int log_target, bool abbreviated, char *file_path, void* unused_opts,
- int unused_opts_len);
+int android_fork_execvp_ext2(int argc, char* argv[], int* status, bool forward_signals,
+ int log_target, bool abbreviated, char* file_path);
+
+// TODO: Actually deprecate this and the below.
+static inline int android_fork_execvp_ext(int argc, char* argv[], int* status, bool ignore_int_quit,
+ int log_target, bool abbreviated, char* file_path,
+ void* unused_opts, int unused_opts_len) {
+ (void)ignore_int_quit;
+ (void)unused_opts;
+ (void)unused_opts_len;
+ return android_fork_execvp_ext2(argc, argv, status, false, log_target, abbreviated, file_path);
+}
/* Similar to above, except abbreviated logging is not available, and if logwrap
* is true, logging is to the Android system log, and if false, there is no
@@ -89,5 +88,3 @@
}
__END_DECLS
-
-#endif /* __LIBS_LOGWRAP_H */
diff --git a/logwrapper/logwrap.c b/logwrapper/logwrap.c
index 8621993..0314f37 100644
--- a/logwrapper/logwrap.c
+++ b/logwrapper/logwrap.c
@@ -36,6 +36,11 @@
#define MIN(a,b) (((a)<(b))?(a):(b))
static pthread_mutex_t fd_mutex = PTHREAD_MUTEX_INITIALIZER;
+// Protected by fd_mutex. These signals must be blocked while modifying as well.
+static pid_t child_pid;
+static struct sigaction old_int;
+static struct sigaction old_quit;
+static struct sigaction old_hup;
#define ERROR(fmt, args...) \
do { \
@@ -289,8 +294,47 @@
}
}
-static int parent(const char *tag, int parent_read, pid_t pid,
- int *chld_sts, int log_target, bool abbreviated, char *file_path) {
+static void signal_handler(int signal_num);
+
+static void block_signals(sigset_t* oldset) {
+ sigset_t blockset;
+
+ sigemptyset(&blockset);
+ sigaddset(&blockset, SIGINT);
+ sigaddset(&blockset, SIGQUIT);
+ sigaddset(&blockset, SIGHUP);
+ pthread_sigmask(SIG_BLOCK, &blockset, oldset);
+}
+
+static void unblock_signals(sigset_t* oldset) {
+ pthread_sigmask(SIG_SETMASK, oldset, NULL);
+}
+
+static void setup_signal_handlers(pid_t pid) {
+ struct sigaction handler = {.sa_handler = signal_handler};
+
+ child_pid = pid;
+ sigaction(SIGINT, &handler, &old_int);
+ sigaction(SIGQUIT, &handler, &old_quit);
+ sigaction(SIGHUP, &handler, &old_hup);
+}
+
+static void restore_signal_handlers() {
+ sigaction(SIGINT, &old_int, NULL);
+ sigaction(SIGQUIT, &old_quit, NULL);
+ sigaction(SIGHUP, &old_hup, NULL);
+ child_pid = 0;
+}
+
+static void signal_handler(int signal_num) {
+ if (child_pid == 0 || kill(child_pid, signal_num) != 0) {
+ restore_signal_handlers();
+ raise(signal_num);
+ }
+}
+
+static int parent(const char* tag, int parent_read, pid_t pid, int* chld_sts, int log_target,
+ bool abbreviated, char* file_path, bool forward_signals) {
int status = 0;
char buffer[4096];
struct pollfd poll_fds[] = {
@@ -308,6 +352,11 @@
int b = 0; // end index of unprocessed data
int sz;
bool found_child = false;
+ // There is a very small chance that opening child_ptty in the child will fail, but in this case
+ // POLLHUP will not be generated below. Therefore, we use a 1 second timeout for poll() until
+ // we receive a message from child_ptty. If this times out, we call waitpid() with WNOHANG to
+ // check the status of the child process and exit appropriately if it has terminated.
+ bool received_messages = false;
char tmpbuf[256];
log_info.btag = basename(tag);
@@ -347,13 +396,15 @@
log_info.abbreviated = abbreviated;
while (!found_child) {
- if (TEMP_FAILURE_RETRY(poll(poll_fds, ARRAY_SIZE(poll_fds), -1)) < 0) {
+ int timeout = received_messages ? -1 : 1000;
+ if (TEMP_FAILURE_RETRY(poll(poll_fds, ARRAY_SIZE(poll_fds), timeout)) < 0) {
ERROR("poll failed\n");
rc = -1;
goto err_poll;
}
if (poll_fds[0].revents & POLLIN) {
+ received_messages = true;
sz = TEMP_FAILURE_RETRY(
read(parent_read, &buffer[b], sizeof(buffer) - 1 - b));
@@ -396,10 +447,20 @@
}
}
- if (poll_fds[0].revents & POLLHUP) {
+ if (!received_messages || (poll_fds[0].revents & POLLHUP)) {
int ret;
+ sigset_t oldset;
- ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
+ if (forward_signals) {
+ // Our signal handlers forward these signals to 'child_pid', but waitpid() may reap
+ // the child, so we must block these signals until we either 1) conclude that the
+ // child is still running or 2) determine the child has been reaped and we have
+ // reset the signals to their original disposition.
+ block_signals(&oldset);
+ }
+
+ int flags = (poll_fds[0].revents & POLLHUP) ? 0 : WNOHANG;
+ ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, flags));
if (ret < 0) {
rc = errno;
ALOG(LOG_ERROR, "logwrap", "waitpid failed with %s\n", strerror(errno));
@@ -408,6 +469,13 @@
if (ret > 0) {
found_child = true;
}
+
+ if (forward_signals) {
+ if (found_child) {
+ restore_signal_handlers();
+ }
+ unblock_signals(&oldset);
+ }
}
}
@@ -472,21 +540,14 @@
}
}
-int android_fork_execvp_ext(int argc, char* argv[], int *status, bool ignore_int_quit,
- int log_target, bool abbreviated, char *file_path,
- void *unused_opts, int unused_opts_len) {
+int android_fork_execvp_ext2(int argc, char* argv[], int* status, bool forward_signals,
+ int log_target, bool abbreviated, char* file_path) {
pid_t pid;
int parent_ptty;
- int child_ptty;
- struct sigaction intact;
- struct sigaction quitact;
sigset_t blockset;
sigset_t oldset;
int rc = 0;
- LOG_ALWAYS_FATAL_IF(unused_opts != NULL);
- LOG_ALWAYS_FATAL_IF(unused_opts_len != 0);
-
rc = pthread_mutex_lock(&fd_mutex);
if (rc) {
ERROR("failed to lock signal_fd mutex\n");
@@ -494,7 +555,7 @@
}
/* Use ptty instead of socketpair so that STDOUT is not buffered */
- parent_ptty = TEMP_FAILURE_RETRY(open("/dev/ptmx", O_RDWR));
+ parent_ptty = TEMP_FAILURE_RETRY(posix_openpt(O_RDWR | O_CLOEXEC));
if (parent_ptty < 0) {
ERROR("Cannot create parent ptty\n");
rc = -1;
@@ -509,27 +570,26 @@
goto err_ptty;
}
- child_ptty = TEMP_FAILURE_RETRY(open(child_devname, O_RDWR));
- if (child_ptty < 0) {
- ERROR("Cannot open child_ptty\n");
- rc = -1;
- goto err_child_ptty;
+ if (forward_signals) {
+ // Block these signals until we have the child pid and our signal handlers set up.
+ block_signals(&oldset);
}
- sigemptyset(&blockset);
- sigaddset(&blockset, SIGINT);
- sigaddset(&blockset, SIGQUIT);
- pthread_sigmask(SIG_BLOCK, &blockset, &oldset);
-
pid = fork();
if (pid < 0) {
- close(child_ptty);
ERROR("Failed to fork\n");
rc = -1;
goto err_fork;
} else if (pid == 0) {
pthread_mutex_unlock(&fd_mutex);
- pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+ unblock_signals(&oldset);
+
+ setsid();
+
+ int child_ptty = TEMP_FAILURE_RETRY(open(child_devname, O_RDWR | O_CLOEXEC));
+ if (child_ptty < 0) {
+ FATAL_CHILD("Cannot open child_ptty: %s\n", strerror(errno));
+ }
close(parent_ptty);
dup2(child_ptty, 1);
@@ -538,27 +598,23 @@
child(argc, argv);
} else {
- close(child_ptty);
- if (ignore_int_quit) {
- struct sigaction ignact;
-
- memset(&ignact, 0, sizeof(ignact));
- ignact.sa_handler = SIG_IGN;
- sigaction(SIGINT, &ignact, &intact);
- sigaction(SIGQUIT, &ignact, &quitact);
+ if (forward_signals) {
+ setup_signal_handlers(pid);
+ unblock_signals(&oldset);
}
- rc = parent(argv[0], parent_ptty, pid, status, log_target,
- abbreviated, file_path);
+ rc = parent(argv[0], parent_ptty, pid, status, log_target, abbreviated, file_path,
+ forward_signals);
+
+ if (forward_signals) {
+ restore_signal_handlers();
+ }
}
- if (ignore_int_quit) {
- sigaction(SIGINT, &intact, NULL);
- sigaction(SIGQUIT, &quitact, NULL);
- }
err_fork:
- pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-err_child_ptty:
+ if (forward_signals) {
+ unblock_signals(&oldset);
+ }
err_ptty:
close(parent_ptty);
err_open:
diff --git a/logwrapper/logwrapper.c b/logwrapper/logwrapper.c
index 33454c6..e786609 100644
--- a/logwrapper/logwrapper.c
+++ b/logwrapper/logwrapper.c
@@ -79,8 +79,7 @@
usage();
}
- rc = android_fork_execvp_ext(argc, &argv[0], &status, true,
- log_target, abbreviated, NULL, NULL, 0);
+ rc = android_fork_execvp_ext2(argc, &argv[0], &status, true, log_target, abbreviated, NULL);
if (!rc) {
if (WIFEXITED(status))
rc = WEXITSTATUS(status);
diff --git a/property_service/libpropertyinfoserializer/Android.bp b/property_service/libpropertyinfoserializer/Android.bp
index 51c1226..aa02a3a 100644
--- a/property_service/libpropertyinfoserializer/Android.bp
+++ b/property_service/libpropertyinfoserializer/Android.bp
@@ -1,7 +1,6 @@
cc_defaults {
name: "propertyinfoserializer_defaults",
host_supported: true,
- vendor_available: true,
cpp_std: "experimental",
cppflags: [
"-Wall",
@@ -9,8 +8,8 @@
"-Werror",
],
static_libs: [
- "libpropertyinfoparser",
"libbase",
+ "libpropertyinfoparser",
],
}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index df1d929..7097a12 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -334,6 +334,15 @@
LOCAL_MODULE_STEM := ld.config.txt
include $(BUILD_PREBUILT)
+# Returns the unique installed basenames of a module, or module.so if there are
+# none. The guess is to handle cases like libc, where the module itself is
+# marked uninstallable but a symlink is installed with the name libc.so.
+# $(1): list of libraries
+# $(2): suffix to to add to each library (not used for guess)
+define module-installed-files-or-guess
+$(foreach lib,$(1),$(or $(strip $(sort $(notdir $(call module-installed-files,$(lib)$(2))))),$(lib).so))
+endef
+
#######################################
# llndk.libraries.txt
include $(CLEAR_VARS)
@@ -342,13 +351,13 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
LOCAL_MODULE_STEM := $(call append_vndk_version,$(LOCAL_MODULE))
include $(BUILD_SYSTEM)/base_rules.mk
-$(LOCAL_BUILT_MODULE): PRIVATE_LLNDK_LIBRARIES := $(LLNDK_LIBRARIES)
+$(LOCAL_BUILT_MODULE): PRIVATE_LLNDK_LIBRARIES := $(call module-installed-files-or-guess,$(LLNDK_LIBRARIES),)
$(LOCAL_BUILT_MODULE):
@echo "Generate: $@"
@mkdir -p $(dir $@)
$(hide) echo -n > $@
$(hide) $(foreach lib,$(PRIVATE_LLNDK_LIBRARIES), \
- echo $(lib).so >> $@;)
+ echo $(lib) >> $@;)
#######################################
# vndksp.libraries.txt
@@ -358,13 +367,13 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
LOCAL_MODULE_STEM := $(call append_vndk_version,$(LOCAL_MODULE))
include $(BUILD_SYSTEM)/base_rules.mk
-$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_SAMEPROCESS_LIBRARIES := $(VNDK_SAMEPROCESS_LIBRARIES)
+$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_SAMEPROCESS_LIBRARIES := $(call module-installed-files-or-guess,$(VNDK_SAMEPROCESS_LIBRARIES),.vendor)
$(LOCAL_BUILT_MODULE):
@echo "Generate: $@"
@mkdir -p $(dir $@)
$(hide) echo -n > $@
$(hide) $(foreach lib,$(PRIVATE_VNDK_SAMEPROCESS_LIBRARIES), \
- echo $(lib).so >> $@;)
+ echo $(lib) >> $@;)
#######################################
# vndkcore.libraries.txt
@@ -374,13 +383,13 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
LOCAL_MODULE_STEM := $(call append_vndk_version,$(LOCAL_MODULE))
include $(BUILD_SYSTEM)/base_rules.mk
-$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_CORE_LIBRARIES := $(VNDK_CORE_LIBRARIES)
+$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_CORE_LIBRARIES := $(call module-installed-files-or-guess,$(VNDK_CORE_LIBRARIES),.vendor)
$(LOCAL_BUILT_MODULE):
@echo "Generate: $@"
@mkdir -p $(dir $@)
$(hide) echo -n > $@
$(hide) $(foreach lib,$(PRIVATE_VNDK_CORE_LIBRARIES), \
- echo $(lib).so >> $@;)
+ echo $(lib) >> $@;)
#######################################
# vndkprivate.libraries.txt
@@ -390,13 +399,13 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
LOCAL_MODULE_STEM := $(call append_vndk_version,$(LOCAL_MODULE))
include $(BUILD_SYSTEM)/base_rules.mk
-$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_PRIVATE_LIBRARIES := $(VNDK_PRIVATE_LIBRARIES)
+$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_PRIVATE_LIBRARIES := $(call module-installed-files-or-guess,$(VNDK_PRIVATE_LIBRARIES),.vendor)
$(LOCAL_BUILT_MODULE):
@echo "Generate: $@"
@mkdir -p $(dir $@)
$(hide) echo -n > $@
$(hide) $(foreach lib,$(PRIVATE_VNDK_PRIVATE_LIBRARIES), \
- echo $(lib).so >> $@;)
+ echo $(lib) >> $@;)
#######################################
# sanitizer.libraries.txt
diff --git a/rootdir/avb/Android.bp b/rootdir/avb/Android.bp
new file mode 100644
index 0000000..85d2786
--- /dev/null
+++ b/rootdir/avb/Android.bp
@@ -0,0 +1,20 @@
+filegroup {
+ name: "q-gsi_avbpubkey",
+ srcs: [
+ "q-gsi.avbpubkey",
+ ],
+}
+
+filegroup {
+ name: "r-gsi_avbpubkey",
+ srcs: [
+ "r-gsi.avbpubkey",
+ ],
+}
+
+filegroup {
+ name: "s-gsi_avbpubkey",
+ srcs: [
+ "s-gsi.avbpubkey",
+ ],
+}
diff --git a/rootdir/etc/ld.config.legacy.txt b/rootdir/etc/ld.config.legacy.txt
index c47b7f6..bb8d4d0 100644
--- a/rootdir/etc/ld.config.legacy.txt
+++ b/rootdir/etc/ld.config.legacy.txt
@@ -179,6 +179,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
diff --git a/rootdir/etc/ld.config.txt b/rootdir/etc/ld.config.txt
index 5b92d48..60035aa 100644
--- a/rootdir/etc/ld.config.txt
+++ b/rootdir/etc/ld.config.txt
@@ -420,6 +420,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
@@ -641,6 +642,7 @@
namespace.neuralnetworks.link.system.shared_libs += liblog.so
namespace.neuralnetworks.link.system.shared_libs += libm.so
namespace.neuralnetworks.link.system.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.system.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.system.shared_libs += libsync.so
namespace.neuralnetworks.link.system.shared_libs += libvndksupport.so
@@ -782,6 +784,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
diff --git a/rootdir/etc/ld.config.vndk_lite.txt b/rootdir/etc/ld.config.vndk_lite.txt
index 8a27c7b..b9b95a6 100644
--- a/rootdir/etc/ld.config.vndk_lite.txt
+++ b/rootdir/etc/ld.config.vndk_lite.txt
@@ -344,6 +344,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
@@ -445,6 +446,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
@@ -585,6 +587,7 @@
namespace.neuralnetworks.link.default.shared_libs += liblog.so
namespace.neuralnetworks.link.default.shared_libs += libm.so
namespace.neuralnetworks.link.default.shared_libs += libnativewindow.so
+namespace.neuralnetworks.link.default.shared_libs += libneuralnetworks_packageinfo.so
namespace.neuralnetworks.link.default.shared_libs += libsync.so
namespace.neuralnetworks.link.default.shared_libs += libvndksupport.so
diff --git a/rootdir/init.environ.rc.in b/rootdir/init.environ.rc.in
index 17f6596..50005d9 100644
--- a/rootdir/init.environ.rc.in
+++ b/rootdir/init.environ.rc.in
@@ -5,7 +5,7 @@
export ANDROID_ASSETS /system/app
export ANDROID_DATA /data
export ANDROID_STORAGE /storage
- export ANDROID_RUNTIME_ROOT /apex/com.android.art
+ export ANDROID_ART_ROOT /apex/com.android.art
export ANDROID_I18N_ROOT /apex/com.android.i18n
export ANDROID_TZDATA_ROOT /apex/com.android.tzdata
export EXTERNAL_STORAGE /sdcard
diff --git a/rootdir/init.rc b/rootdir/init.rc
index d5fed5a..c61fd90 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -69,18 +69,22 @@
service boringssl_self_test32 /system/bin/boringssl_self_test32
setenv BORINGSSL_SELF_TEST_CREATE_FLAG true # Any nonempty value counts as true
reboot_on_failure reboot,boringssl-self-check-failed
+ stdio_to_kmsg
service boringssl_self_test64 /system/bin/boringssl_self_test64
setenv BORINGSSL_SELF_TEST_CREATE_FLAG true # Any nonempty value counts as true
reboot_on_failure reboot,boringssl-self-check-failed
+ stdio_to_kmsg
service boringssl_self_test_apex32 /apex/com.android.conscrypt/bin/boringssl_self_test32
setenv BORINGSSL_SELF_TEST_CREATE_FLAG true # Any nonempty value counts as true
reboot_on_failure reboot,boringssl-self-check-failed
+ stdio_to_kmsg
service boringssl_self_test_apex64 /apex/com.android.conscrypt/bin/boringssl_self_test64
setenv BORINGSSL_SELF_TEST_CREATE_FLAG true # Any nonempty value counts as true
reboot_on_failure reboot,boringssl-self-check-failed
+ stdio_to_kmsg
on init
sysclktz 0
@@ -154,6 +158,14 @@
mkdir /mnt/user/0/self 0755 root root
mkdir /mnt/user/0/emulated 0755 root root
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/0 0755 root root
+ mkdir /mnt/pass_through/0/self 0755 root root
+ mkdir /mnt/pass_through/0/emulated 0755 root root
+ mkdir /mnt/pass_through/0/emulated/0 0755 root root
+
mkdir /mnt/expand 0771 system system
mkdir /mnt/appfuse 0711 root root
@@ -678,6 +690,8 @@
# Mount default storage into root namespace
mount none /mnt/user/0 /storage bind rec
mount none none /storage slave rec
+ # Bootstrap the emulated volume for the pass_through directory for user 0
+ mount none /data/media /mnt/pass_through/0/emulated bind rec
on zygote-start && property:persist.sys.fuse=false
# Mount default storage into root namespace
mount none /mnt/runtime/default /storage bind rec